#include <algorithm>
#include <chrono>
#include <cstdio>
#include <ctime>
#include <functional>
#include <iostream>
#include <memory>
#include <ncurses.h>
#include <string>
#include <thread>
#include <unistd.h>
#include <vector>

/*
  todo
  figure out namespaces, using, and auto
  formalize timer struct
  read about std function and std bind
  try to do with objects / classes instead
  centralize into event sender and subscriber
*/


// calls callbackfunc on specified interval based on accumulated deltatime
class timer {
private:
  double accumulator = 0;
  int triggeramount = 0;
  double time_interval = 1; // only display every 1 seconds
 
public:
  std::string name;
  int triggercounter = 0;
  bool is_infinite = false;
  std::function<void(const timer&)> callbackfunc;
  bool is_expired = false;

  //infinite timer
  timer(std::string name_input, size_t interval_input,
        std::function<void(const timer &)> callback_input)
      : time_interval(interval_input), name(name_input), is_infinite(true),
        callbackfunc(callback_input) {}

  //limited timer
  timer(std::string name, size_t interval_input, int triggeramount,
        std::function<void(const timer &)> callback)
      : triggeramount(triggeramount), time_interval(interval_input), name(name),
        callbackfunc(callback) {}

  // callbackfunc once enough time has accumulated
  void updatetime(double DeltaTime) {
    accumulator += DeltaTime;
    if (!is_expired) {
      if (accumulator >= time_interval) {
        callbackfunc(*this);
        accumulator -= time_interval;
        triggercounter++;
        if (!is_infinite && triggercounter >= triggeramount) {
          is_expired = true;
        }
      }
    }
  }


};

void myupdatedisplay(const timer &timer_input) {
  mvprintw(timer_input.triggercounter, timer_input.triggercounter, "hello %d",
           timer_input.triggercounter);
}

// manage collection of timers
class timermanager {
  std::vector<std::unique_ptr<timer>> timers;

public:
  void addtimer(std::unique_ptr<timer> input_timer) {
    timers.push_back(std::move(input_timer)); }

  void updatetimers(double dtime) {
    for (auto &mytimer : timers) {
      mytimer->updatetime(dtime);
      mvprintw(12, 0, "updated timer %s", mytimer->name.c_str());
    }
    timers.erase(std::remove_if(timers.begin(), timers.end(),
                                [](auto &timer) { return timer->is_expired; }),
                 timers.end());
    // implement delete timers
    ;
    refresh();
  }
};

int main() {
  initscr();
  nodelay(stdscr, FALSE);
  refresh();
  // printf("verification\n");

  auto starttime = std::chrono::steady_clock::now(); // initial starttime
  auto clocktimer = std::make_unique<timer>("secondsprinter", 1, 10, myupdatedisplay);
  timermanager mytimermanager;  
  mytimermanager.addtimer(std::move(clocktimer));
  
  mvprintw(5, 5, "timer added");
  // calculate delta between current and previous time
  while (true) {
    auto currenttime = std::chrono::steady_clock::now();
    std::chrono::duration<double> myDeltaTime = currenttime - starttime;
    double dtime = myDeltaTime.count();
    mytimermanager.updatetimers(dtime);

    starttime = currenttime;
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
  }

  getch();
  endwin();

  return 0;
}