#pragma once

#include <twist/stdlike/mutex.hpp>
#include <twist/stdlike/condition_variable.hpp>
#include <twist/support/locking.hpp>

#include <cstddef>

namespace solutions {

class CyclicBarrier {
 public:
  explicit CyclicBarrier(size_t num_threads) : barrier_border_(num_threads) {
    threads_needed_cross_count_ = num_threads;
    threads_can_cross_count_[0] = threads_can_cross_count_[1] = 0;
    cur_queue_index_ = 0;
  }

  void PassThrough() {
    auto barrier_lock = twist::LockUnique(barrier_mutex_);
    size_t local_cur_queue_index = cur_queue_index_;

    --threads_needed_cross_count_;

    if (threads_needed_cross_count_ == 0) {
      threads_can_cross_count_[cur_queue_index_] = barrier_border_ - 1;

      threads_needed_cross_count_ = barrier_border_;

      all_threads_are_here_.notify_all();
      cur_queue_index_ = 1 - cur_queue_index_;
    } else {
      while (threads_can_cross_count_[local_cur_queue_index] == 0) {
        all_threads_are_here_.wait(barrier_lock);
      }
      --threads_can_cross_count_[local_cur_queue_index];
    }
  }

 private:
  twist::condition_variable all_threads_are_here_;
  twist::mutex barrier_mutex_;
  size_t threads_needed_cross_count_;
  const size_t barrier_border_;
  size_t threads_can_cross_count_[2];

  size_t cur_queue_index_;
};

}  // namespace solutions