#include <fcntl.h>
#include <sys/fanotify.h>
#include <unistd.h>
 
#include <cstdlib>
#include <cstring>
#include <iostream>
 
using namespace std;
 
void ExitProgram() {
  cerr << strerror(errno) << endl;
  exit(EXIT_FAILURE);
}
 
int main() {
  /*
  Набор флагов, отвечающий за установку notification class'а слушающего приложения,
  а также установка повередения файлового дескриптора.
  */
  unsigned int flags =
    FAN_CLASS_CONTENT | // notification class, который нужен, если создается антивирус
    FAN_UNLIMITED_QUEUE; // флаг поведения, убирающий ограничеие на размер очереди событий
 
  /*
  Набор флагов, отвечающий за файловый статус файлового дескриптора.
  Это те же флаги, которые передаются при открытии обычного файла
  системным вызовом open.
  */
  unsigned int event_f_flags = O_RDONLY | O_LARGEFILE;
 
  /*
  Создаем внуренний объект ядра ОС, который называется fanotify notification group.
  Функция fanotify_init возвращает файловый дескриптор для доступа к очереди событий,
  которая принадлежит только что созданной fanotify notification group.
  */
  int fng = fanotify_init(flags, event_f_flags);
  if (fng == -1) {
    ExitProgram();
  }
  cout << "fanotify_init\n";
 
  /*
  Набор флагов, которые описывают, должны ли быть взведены флаги mark и/или
  ignore для определенного набора событий для объекта файловой системы в fanotify
  notification group. Объект файловой системы передается двумя последними параметрами
  в функции fanotify_mark.
  */
  flags = FAN_MARK_ADD | FAN_MARK_MOUNT;
 
  /*
  Набор флагов, которые описывают те события, которые должны быть промаркированы
  или проигнорированы в данном fanotify notification group. Маркирование или
  игнорирование событий задается с помощью проедыдещего набора флагов flags.
  */
  uint64_t mask = FAN_ACCESS_PERM;
 
  if (fanotify_mark(fng, flags, mask, AT_FDCWD, "/root/temp/loopfs") == -1) {
    ExitProgram();
  }
  cout << "fanotify_mark\n";
 
  // Установим исключение на один из объектов в папке /root/temp/loopfs
  if (fanotify_mark(fng, FAN_MARK_ADD | FAN_MARK_IGNORED_MASK, FAN_ACCESS_PERM, AT_FDCWD, "/root/temp/loopfs/folder/subfolder/test1.txt") == -1) {
    ExitProgram();
  }
  cout << "fanotify_mark\n";
  
  struct fanotify_event_metadata buffer [200];
  const struct fanotify_event_metadata* metadata = nullptr;
 
  // Читаем событие из очереди событий, которая принадлежит fanotify notification group
  size_t length = read(fng, buffer, sizeof(buffer));
  if (length == -1) {
    ExitProgram();
  }
  cout << "length = " << length << endl;
 
  metadata = buffer;
  
  // Начинаем обрабатывать прочитанные события
  while (FAN_EVENT_OK(metadata, length)) {
 
    // Проверяем версию структуры fanotify_event_metadata
    if (metadata->vers != FANOTIFY_METADATA_VERSION) {
      cerr << "Mismatch of fanotify metadata version\n";
      return EXIT_FAILURE;
    }
 
    // Проверяем, что файловый дестриптом объекта файловой системы корректен
    if (metadata->fd > 0) {
 
      // Проверямем, что полученное событие это событие FAN_ACCESS_PERM
      if (metadata->mask & FAN_ACCESS_PERM) {
        cout << "FAN_ACCESS_PERM: fd = " << metadata->fd << endl;
 
        /*
        Подготавливаем ответ по событию - резрешить или запретить
        (В данном случае мы запрещаем действие над объектом файловой системы)
        */
        struct fanotify_response response;
        response.fd = metadata->fd;
        response.response = FAN_DENY;
 
        // Отправляем ответ
        if (write(fng, &response, sizeof(response)) == -1) {
          ExitProgram();
        }
 
        // Закрываем файловый дескриптор объекта операционной системы
        if (close(metadata->fd) == -1) {
          ExitProgram();
        }
      }
    }
    else {
      cerr << "Invalid metadata->fd\n";
    }
 
    // Переходим к следующему событию
    metadata = FAN_EVENT_NEXT(metadata, length);
  }
 
  // Закрываем файловый дескриптор fanotify notification group
  if (close(fng) == -1) {
    ExitProgram();
  }
  cout << "SUCCESS\n";
 
  return EXIT_SUCCESS;
}

template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
bool check_is_integral(const std::string& str) {
  // Случай str == ''
  if (str.empty()) {
    return false;
  }
 
  // Случай str == '+' или str == '-'
  if (str.length() == 1 && (str[0] == '-' || str[0] == '+')) {
    return false;
  }
 
  // Случай str == '000' или str == '+000' или str == '-000'
  std::size_t begin = 0;
  if (str[begin] == '-' || str[begin] == '+') {
    begin++;
  }
  while (begin < str.length() && str[begin] == '0') {
    begin++;
  }
  if (begin >= str.length()) {
    return true;
  }
 
  // Основной алгоритм
  begin = 0;
  bool is_negative = false;
 
  if (std::is_signed<T>::value) {
    if (str[begin] == '-') {
      is_negative = true;
    }
    if (str[begin] == '-' || str[begin] == '+') {
      begin++;
    }
  } else if (str[begin] == '+') {
    begin++;
  }
 
  // Убираем ведущие нули
  while (str[begin] == '0') {
    begin++;
  }
 
  // Случай str == '1234a56'
  for (std::size_t i = begin; i < str.length(); ++i) {
    if (!std::isdigit(str[i])) {
      return false;
    }
  }
 
  // Проверка границ
  std::string ref_value =
      is_negative ? std::to_string(std::numeric_limits<T>::min()).substr(1)
                  : std::to_string(std::numeric_limits<T>::max());
 
  if ((str.length() - begin) < ref_value.length()) {
    return true;
  } else if ((str.length() - begin) > ref_value.length()) {
    return false;
  } else {
    for (std::size_t i = begin; i < str.length(); ++i) {
      if (ref_value[i - begin] > str[i]) {
        return true;
      } else if (ref_value[i - begin] < str[i]) {
        return false;
      }
    }
  }
 
  return true;
}

#pragma once
 
// Очередь реализуется согласано книге Anthony Williams -
// "C++ Concurrency in Action: Practical Multithreading".
// Смотреть главу 6, раздел 6.2
 
#include <condition_variable>
#include <memory>
#include <mutex>
 
template <typename T>
class ThreadSafeQueue {
 private:
  using LockGuard = std::lock_guard<std::mutex>;
  using UniqueLock = std::unique_lock<std::mutex>;
 
  // Очередь реализуется в виде односвязного списка
  struct Node {
    // Данные в узле списка
    std::shared_ptr<T> data = nullptr;
 
    // Указатель на следующей элемент в списке
    std::unique_ptr<Node> next = nullptr;
  };
 
 private:
  // Потокобезопасный доступ к концу очереди
  const Node* get_tail() const {
    LockGuard tail_lock(m_tail_mutex);
    return m_tail;
  }
 
  // Извлечение из начала очереди
  std::unique_ptr<Node> pop_head() {
    std::unique_ptr<Node> old_head = std::move(m_head);
    m_head = std::move(old_head->next);
    return std::move(old_head);
  }
 
  // Ожидание появления данных в очереди
  UniqueLock wait_for_data() {
    UniqueLock head_lock(m_head_mutex);
    m_data_cond.wait(head_lock, [this] { return m_head.get() != get_tail(); });
    return std::move(head_lock);
  }
 
 public:
  // Создаем фиктивный узел, чтобы next никогда не указывал на nullptr.
  // Это необходимо для потокобезопасной работы и удобства.
  ThreadSafeQueue() : m_head(std::make_unique<Node>()), m_tail(m_head.get()) {}
  ThreadSafeQueue(const ThreadSafeQueue&) = delete;
  ThreadSafeQueue& operator=(const ThreadSafeQueue&) = delete;
 
  // Проверка наличия элемента и если он есть, то извлечение
  std::shared_ptr<T> try_pop() {
    LockGuard head_lock(m_head_mutex);
    if (m_head.get() == get_tail()) {
      return nullptr;
    }
 
    std::unique_ptr<Node> old_head = pop_head();
    return old_head->data;
  }
 
  // Проверка наличия элемента и если он есть, то извлечение
  bool try_pop(T& value) {
    LockGuard head_lock(m_head_mutex);
    if (m_head.get() == get_tail()) {
      return false;
    }
 
    value = std::move(*m_head->data);
    pop_head();
    return true;
  }
 
  // Извлечение элемента из очереди с ожиданием
  std::shared_ptr<T> wait_and_pop() {
    UniqueLock head_lock(wait_for_data());
    std::unique_ptr<Node> old_head = pop_head();
    return old_head->data;
  }
 
  // Извлечение элемента из очереди с ожиданием
  void wait_and_pop(T& value) {
    UniqueLock head_lock(wait_for_data());
    value = std::move(*m_head->data);
    pop_head();
  }
 
  // Вставка нового элемента в очередь. Надо понимать тот факт,
  // что фиктивная нода всегда находится в конце связного списка.
  // Если на фиктивную ноду указывают начало и конец очереди,
  // значит очередь пуста.
  void push(T new_value) {
    std::shared_ptr<T> new_data = std::make_shared<T>(std::move(new_value));
    std::unique_ptr<Node> new_dummy_node = std::make_unique<Node>();
    {
      LockGuard tail_lock(m_tail_mutex);
      Node* old_tail = m_tail;
      m_tail = new_dummy_node.get();
      old_tail->data = std::move(new_data);
      old_tail->next = std::move(new_dummy_node);
    }
    m_data_cond.notify_one();
  }
 
  bool empty() const {
    LockGuard head_lock(m_head_mutex);
    return m_head.get() == get_tail();
  }
 
 private:
  // Начало очереди
  mutable std::mutex m_head_mutex;
  std::unique_ptr<Node> m_head;
 
  // Конец очереди
  mutable std::mutex m_tail_mutex;
  Node* m_tail;
 
  std::condition_variable m_data_cond;
};

#include <algorithm>
#include <future>
#include <iostream>
#include <utility>
 
#include <gtest/gtest.h>
#include "thread_safe_queue.h"
 
class ThreadSafeQueueTest : public ::testing::Test {
 public:
  using Pair = std::pair<std::size_t, std::size_t>;
 
  void push_to_queue(ThreadSafeQueue<Pair>& queue, std::size_t number,
                     std::size_t count) {
    for (std::size_t i = 0; i < count; ++i) {
      queue.push(std::make_pair(number, i));
    }
  }
 
  std::vector<Pair> wait_and_pop_from_queue(ThreadSafeQueue<Pair>& queue,
                                            std::size_t count) {
    std::vector<Pair> pairs(count);
    for (std::size_t i = 0; i < count; ++i) {
      queue.wait_and_pop(pairs[i]);
    }
    return pairs;
  }
 
  std::vector<Pair> try_pop_from_queue(ThreadSafeQueue<Pair>& queue,
                                       std::size_t count) {
    std::vector<Pair> pairs;
    pairs.reserve(count);
    for (std::size_t i = 0; i < count; ++i) {
      auto result = queue.try_pop();
      if (result) {
        pairs.push_back(*result);
      }
    }
    return pairs;
  }
};
 
TEST_F(ThreadSafeQueueTest, one_push_pop) {
  ThreadSafeQueue<std::size_t> queue;
  ASSERT_TRUE(queue.empty());
 
  queue.push(1);
  ASSERT_FALSE(queue.empty());
 
  std::size_t pop_result = *queue.try_pop();
  ASSERT_TRUE(queue.empty());
  ASSERT_EQ(queue.try_pop(), nullptr);
  ASSERT_EQ(pop_result, 1);
 
  queue.push(2);
  ASSERT_FALSE(queue.empty());
 
  ASSERT_TRUE(queue.try_pop(pop_result));
  ASSERT_TRUE(queue.empty());
  ASSERT_EQ(pop_result, 2);
}
 
TEST_F(ThreadSafeQueueTest, many_push_pop) {
  ThreadSafeQueue<std::size_t> queue;
  ASSERT_TRUE(queue.empty());
 
  queue.push(1);
  queue.push(2);
  ASSERT_FALSE(queue.empty());
 
  std::size_t pop_result = *queue.try_pop();
  ASSERT_FALSE(queue.empty());
  ASSERT_EQ(pop_result, 1);
 
  ASSERT_TRUE(queue.try_pop(pop_result));
  ASSERT_TRUE(queue.empty());
  ASSERT_EQ(pop_result, 2);
}
 
TEST_F(ThreadSafeQueueTest, wait_and_pop_from_queue) {
  ThreadSafeQueue<Pair> queue;
 
  std::future<void> push1 = std::async(&ThreadSafeQueueTest::push_to_queue,
                                       this, std::ref(queue), 0, 5);
 
  std::future<void> push2 = std::async(&ThreadSafeQueueTest::push_to_queue,
                                       this, std::ref(queue), 1, 5);
 
  std::future<std::vector<Pair>> pop1 = std::async(
      &ThreadSafeQueueTest::wait_and_pop_from_queue, this, std::ref(queue), 10);
 
  push1.get();
  push2.get();
  auto result = pop1.get();
  std::stable_partition(result.begin(), result.end(),
                        [](const Pair& pair) { return pair.first == 0; });
 
  std::vector<Pair> expected = {{0, 0},
                                {0, 1},
                                {0, 2},
                                {0, 3},
                                {0, 4},
                                {1, 0},
                                {1, 1},
                                {1, 2},
                                {1, 3},
                                {1, 4}};
 
  ASSERT_TRUE(queue.empty());
  ASSERT_EQ(queue.try_pop(), nullptr);
  ASSERT_EQ(result, expected);
}
 
TEST_F(ThreadSafeQueueTest, try_pop_from_queue) {
  ThreadSafeQueue<Pair> queue;
 
  std::future<void> push1 = std::async(&ThreadSafeQueueTest::push_to_queue,
                                       this, std::ref(queue), 0, 5);
 
  std::future<void> push2 = std::async(&ThreadSafeQueueTest::push_to_queue,
                                       this, std::ref(queue), 1, 5);
 
  std::future<std::vector<Pair>> pop1 = std::async(
      &ThreadSafeQueueTest::try_pop_from_queue, this, std::ref(queue), 10);
 
  push1.get();
  push2.get();
  auto result = pop1.get();
 
  while (!queue.empty()) {
    result.push_back(*queue.try_pop());
  }
 
  std::stable_partition(result.begin(), result.end(),
                        [](const Pair& pair) { return pair.first == 0; });
 
  std::vector<Pair> expected = {{0, 0},
                                {0, 1},
                                {0, 2},
                                {0, 3},
                                {0, 4},
                                {1, 0},
                                {1, 1},
                                {1, 2},
                                {1, 3},
                                {1, 4}};
 
  ASSERT_TRUE(queue.empty());
  ASSERT_EQ(queue.try_pop(), nullptr);
  ASSERT_EQ(result, expected);
}
 
int main(int argc, char** argv) {
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}

#include <atomic>
#include <condition_variable>
#include <functional>
#include <iostream>
#include <list>
#include <mutex>
#include <thread>
#include <vector>
 
class Executor
{
public:
  Executor(): _firstExec{true}, _isStop{false}
  {}
 
  ~Executor()
  {
    {
      std::lock_guard<std::mutex> lock(_mutex);
      _isStop = true;
    }
    _cv.notify_one();
 
    if (!_threads.empty())
    {
      _threads.at(0).join();
    }
  }
  
  void Exec(std::function<void()> func)
  {
    {
      std::lock_guard<std::mutex> lock(_mutex);
      _funcs.push_back(func);
    }
    _cv.notify_one();
 
    if (_firstExec)
    {
      _threads.push_back(std::thread(&Executor::Run, this));
      _firstExec = false;
    }
  }
 
private:
  void Run()
  {
    while (!_isStop)
    {
      std::unique_lock<std::mutex> lock(_mutex);
      
      if (!_funcs.empty())
      {
        auto func = _funcs.front();
        _funcs.pop_front();
        lock.unlock();
        func();
      }
      else
      {
        _cv.wait(lock, [this] () { return !_funcs.empty() || _isStop; });
      }
    }
  }
  
  bool _firstExec;
  std::atomic<bool> _isStop;
  
  std::list<std::function<void()>> _funcs;
  std::vector<std::thread> _threads;
 
  std::mutex _mutex;
  std::condition_variable _cv;
};
 
void TestFunc(Executor & executor, int number)
{
  executor.Exec([number]() {
    std::cout << "HI: " << number << std::endl;
  });
}
 
int main()
{
  Executor executor;
  for (int i = 0; i < 6; ++i)
  {
    if (i > 0 && i % 2 == 0)
    {
      std::cout << "Main: HI" << std::endl;
      std::this_thread::sleep_for(std::chrono::seconds{2});
    }
    TestFunc(executor, i + 1);
  }
 
  (void)std::getchar();
  return 0;
}

int solution (vector<int> &A, vector<int> &B);

#include <iostream>
#include <numeric>
#include <vector>
 
int solution(std::vector<int> & A, std::vector<int> & B)
{
  if (A.size() != B.size())
  {
    std::cout << "Vectors\' sizes not equal!" << std::endl;
    return 0;
  }
 
  std::size_t size = A.size();
 
  if (size == 0)
  {
    std::cout << "Vectors\' sizes are zero!" << std::endl;
    return 0;
  }
 
  if (size == 1)
  {
    std::cout << "Vectors\' sizes are one!" << std::endl; 
    return 0;
  }
 
  int sum1A = A[0];
  int sum1B = B[0];
  int sum2A = std::accumulate(A.begin() + 1, A.end(), 0);
  int sum2B = std::accumulate(B.begin() + 1, B.end(), 0);
  int result = 0;
 
  for (std::size_t i = 1; i < size; ++i)
  {
    if (sum1A == sum1B && sum2A == sum2B && sum1A == sum2A)
    {
      std::cout << "Result index: " << i << std::endl;
      result++;
    }
 
    sum1A += A[i];
    sum1B += B[i];
    sum2A -= A[i];
    sum2B -= B[i];
  }
 
  return result;
}
 
int main()
{
  /*std::vector<int> A = {4, -1, 0, 3};
  std::vector<int> B = {-2, 5, 0, 3};*/
 
  /*std::vector<int> A = {2, -2, -3, 3};
  std::vector<int> B = {0, 0, 4, -4};*/
 
  /*std::vector<int> A = {4, -1, 0, 3};
  std::vector<int> B = {-2, 6, 0, 4};*/
 
  /*std::vector<int> A = {3, 2, 6};
  std::vector<int> B = {4, 1, 6};*/
 
  std::vector<int> A = {1, 4, 2, -2, 5};
  std::vector<int> B = {7, -2, -2, 2, 5};
 
  int result = solution(A, B);
  std::cout << "Solution result: " << result << std::endl;
  return 0;
}

#define FUSE_USE_VERSION 30
 
#include <cstdio>
#include <cstring>
#include <ctime>
#include <fuse.h>
#include <unistd.h>
 
static int my_getattr(const char* path, struct stat* st)
{
  std::printf("[getattr] Called\n");
  std::printf("Attributes of path \"%s\" requested\n", path);
  std::memset(st, 0, sizeof(struct stat));
  
  st->st_uid = getuid();
  st->st_gid = getgid();
  st->st_atime = std::time(nullptr);
  st->st_mtime = std::time(nullptr);
  
  if (std::strcmp(path, "/") == 0)
  {
    st->st_mode = S_IFDIR | 0755;
    st->st_nlink = 2;
  }
  else
  {
    st->st_mode = S_IFREG | 0644;
    st->st_nlink = 1;
    st->st_size = 1024;
  }
 
  return 0;
}
 
static int my_readdir(const char* path,
                      void* buffer,
                      fuse_fill_dir_t filler,
                      off_t offset,
                      struct fuse_file_info* fi)
{
  (void)offset;
  (void)fi;
  std::printf("--> Getting The List of Files of path \"%s\"\n", path);
  
  filler(buffer, ".", nullptr, 0);
  filler(buffer, "..", nullptr, 0);
  
  if (std::strcmp(path, "/") == 0)
  {
    filler(buffer, "file1", nullptr, 0);
    filler(buffer, "file2", nullptr, 0);
  }
  
  return 0;
}
 
static int my_read(const char* path,
                   char* buffer,
                   size_t size,
                   off_t offset,
                   struct fuse_file_info* fi)
{
  (void)fi;
  char file1Text [] = "Hello World From File1!\n";
  char file2Text [] = "Hello World From File2!\n";
  char* selectedText = nullptr;
  
  if (std::strcmp(path, "/file1") == 0)
  {
    selectedText = file1Text;
  }
  else if (std::strcmp(path, "/file2") == 0)
  {
    selectedText = file2Text;
  }
  else
  {
    return -1;
  }
  
  std::memcpy(buffer, selectedText + offset, size);
  return std::strlen(selectedText) - offset;
}
 
int main(int argc, char** argv)
{
  struct fuse_operations operations;
  operations.getattr = my_getattr;
  operations.read = my_read;
  operations.readdir = my_readdir;
  return fuse_main(argc, argv, &operations, nullptr);
}