#include "Jobs.hpp"

#include "Caps.hpp"

namespace molo::example::fw {

void Supervisor::add_worker(const std::string& name) {
  std::lock_guard<std::mutex> lock(mu_);
  if (!workers_.count(name) && workers_.size() >= caps::kMaxWorkers) return;
  workers_[name] = WorkerInfo{name, false, 0};
}

bool Supervisor::start(const std::string& name) {
  std::lock_guard<std::mutex> lock(mu_);
  auto it = workers_.find(name);
  if (it == workers_.end()) return false;
  it->second.running = true;
  return true;
}

bool Supervisor::stop(const std::string& name) {
  std::lock_guard<std::mutex> lock(mu_);
  auto it = workers_.find(name);
  if (it == workers_.end()) return false;
  it->second.running = false;
  return true;
}

bool Supervisor::restart(const std::string& name) {
  std::lock_guard<std::mutex> lock(mu_);
  auto it = workers_.find(name);
  if (it == workers_.end()) return false;
  it->second.running = true;
  ++it->second.restarts;
  return true;
}

std::vector<WorkerInfo> Supervisor::status() const {
  std::lock_guard<std::mutex> lock(mu_);
  std::vector<WorkerInfo> out;
  for (const auto& [k, v] : workers_) out.push_back(v);
  return out;
}

std::string TaskQueue::enqueue(const std::string& kind,
                               const std::string& payload, long delay_sec) {
  std::lock_guard<std::mutex> lock(mu_);
  if (tasks_.size() >= caps::kMaxTasks) return "";
  std::string id = "task-" + std::to_string(next_id_++);
  TaskInfo t{id, kind, payload,
             delay_sec > 0 ? "delayed" : "queued", 0};
  tasks_[id] = t;
  return id;
}

bool TaskQueue::cancel(const std::string& id) {
  std::lock_guard<std::mutex> lock(mu_);
  auto it = tasks_.find(id);
  if (it == tasks_.end()) return false;
  it->second.state = "cancelled";
  return true;
}

bool TaskQueue::retry(const std::string& id) {
  std::lock_guard<std::mutex> lock(mu_);
  auto it = tasks_.find(id);
  if (it == tasks_.end()) return false;
  ++it->second.attempts;
  it->second.state = "queued";
  return true;
}

void TaskQueue::run_inline(TaskInfo& task) {
  task.state = "done";
  std::lock_guard<std::mutex> lock(mu_);
  auto it = tasks_.find(task.id);
  if (it != tasks_.end()) it->second.state = "done";
}

std::vector<TaskInfo> TaskQueue::list() const {
  std::lock_guard<std::mutex> lock(mu_);
  std::vector<TaskInfo> out;
  for (const auto& [k, v] : tasks_) out.push_back(v);
  return out;
}

ReplEntry ReplicationLog::append(const std::string& object,
                                 const std::string& data) {
  std::lock_guard<std::mutex> lock(mu_);
  ReplEntry e;
  e.seq = entries_.size() + 1;
  e.object = object;
  e.data = data;
  e.resolution = "last-writer-wins";
  if (entries_.size() < caps::kMaxReplEntries) entries_.push_back(e);
  return e;
}

std::vector<ReplEntry> ReplicationLog::since(unsigned long seq) const {
  std::lock_guard<std::mutex> lock(mu_);
  std::vector<ReplEntry> out;
  for (const auto& e : entries_) {
    if (e.seq > seq) out.push_back(e);
  }
  return out;
}

unsigned long ReplicationLog::latest() const {
  std::lock_guard<std::mutex> lock(mu_);
  return entries_.size();
}

}  // namespace molo::example::fw