#include <llarp/timer.h>
#include <atomic>
#include <condition_variable>
#include <list>
#include <map>

namespace llarp {
struct timer {
  static uint64_t now() {
    return std::chrono::duration_cast<std::chrono::milliseconds>(
               std::chrono::steady_clock::now().time_since_epoch())
        .count();
  }

  llarp_timer_context * parent;
  void* user;
  uint64_t started;
  uint64_t timeout;
  llarp_timer_handler_func func;
  uint32_t id;

  timer(llarp_timer_context * ctx=nullptr, uint64_t ms = 0, void* _user = nullptr,
        llarp_timer_handler_func _func = nullptr, uint32_t _id=0)
    : parent(ctx), user(_user), started(now()), timeout(ms), func(_func), id(_id) {}

  
  void exec();

  
  static void call(void * user)
  {
    static_cast<timer *>(user)->exec();
  }

  operator llarp_thread_job ()
  {
    return {this, timer::call};
  }
  
};
};  // namespace llarp

struct llarp_timer_context {
  llarp_threadpool * threadpool;
  std::mutex timersMutex;
  std::map<uint32_t, llarp::timer> timers;
  std::mutex tickerMutex;
  std::condition_variable ticker;
  std::chrono::milliseconds nextTickLen = std::chrono::milliseconds(10);

  uint32_t ids = 0;
  std::atomic<bool> _run = true;

  bool run() { return _run.load(); }

  void stop() { _run.store(false); }

  void cancel(uint32_t id, bool lockit = true) {
    std::unique_lock<std::mutex>* lock = nullptr;
    if (lockit) lock = new std::unique_lock<std::mutex>(timersMutex);

    auto itr = timers.find(id);
    if (itr != timers.end()) {
      itr->second.exec();
    }

    if (lock) delete lock;
  }

  void remove(uint32_t id)
  {
    std::unique_lock<std::mutex> lock (timersMutex);
    timers.erase(id);
  }

  uint32_t call_later(void* user, llarp_timer_handler_func func,
                      uint64_t timeout_ms) {
    std::unique_lock<std::mutex> lock(timersMutex);
    uint32_t id = ++ids;
    timers[id] = llarp::timer(this, timeout_ms, user, func, id);
    return id;
  }

  void cancel_all() {
    std::unique_lock<std::mutex> lock(timersMutex);

    std::list<uint32_t> ids;

    for (auto& item : timers) {
      ids.push_back(item.first);
    }

    for (auto id : ids) {
      cancel(id, false);
    }
  }
};

extern "C" {

struct llarp_timer_context* llarp_init_timer() {
  return new llarp_timer_context;
}

uint32_t llarp_timer_call_later(struct llarp_timer_context* t,
                                struct llarp_timeout_job job) {
  return t->call_later(job.user, job.handler, job.timeout);
}

void llarp_free_timer(struct llarp_timer_context** t) {
  if (*t) delete *t;
  *t = nullptr;
}

void llarp_timer_stop(struct llarp_timer_context* t) {
  t->stop();
  {
    std::unique_lock<std::mutex> lock(t->tickerMutex);
  
    auto itr = t->timers.begin();
    while (itr != t->timers.end())
    {
      // timer expired
      llarp_threadpool_queue_job(t->threadpool, itr->second);
      ++itr;
    }
  }
}

void llarp_timer_cancel(struct llarp_timer_context* t, uint32_t id) {
  t->cancel(id);
}

void llarp_timer_run(struct llarp_timer_context* t,
                     struct llarp_threadpool* pool) {
  t->threadpool = pool;
  while (t->run()) {
    std::unique_lock<std::mutex> lock(t->tickerMutex);
    t->ticker.wait_for(lock, t->nextTickLen);
    // we woke up
    auto now = llarp::timer::now();
    auto itr = t->timers.begin();
    while (itr != t->timers.end())
    {
      if(now - itr->second.started >= itr->second.timeout)
      {
        // timer hit
        llarp_threadpool_queue_job(pool, itr->second);
      }
      ++itr;
    }
  }
}
}

namespace llarp
{
  void timer::exec()
  {
    if (func) {
      auto ms = now();
      auto diff = ms - started;
      if (diff >= timeout)
        func(user, timeout, 0);
      else
        func(user, timeout, diff);
    }
    if(parent)
      parent->remove(id);
  }
}