#pragma once

#include <vector>

namespace tpcc {
    namespace solutions {

        class TournamentTreeLock {
        public:
            explicit TournamentTreeLock(size_t num_threads) {
              num = num_threads;
              levels.assign(num_threads, 0);
              victim.resize(num_threads, 0);
            }

            void Lock(size_t thread_index) {
              for (size_t level = 1; level < num; level++) {
                levels[thread_index] = level;
                victim[level] = thread_index;

                bool conflicts_exist = true;
                while(conflicts_exist) {
                  conflicts_exist = false;
                  for(int another_thread = 1; another_thread < num; another_thread++) {
                    if(another_thread!=thread_index && levels[another_thread] >= level && victim[level] == thread_index) {
                      conflicts_exist = true;
                      break;
                    }
                  }
                }
              }
            }
            void Unlock(size_t thread_index) {
              levels[thread_index] = 0;
            }

        private:
            size_t num;
            std::vector<size_t> levels;
            std::vector<size_t> victim;
        };

    } // namespace solutions
} // namespace tpcc