#include <Windows.h>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <SFML/Graphics.hpp>

void init();

void update(float dt);
void postUpdate(float dt);

void action(void(*func) (float), int mapId);

void render(float dt);
void physics(float dt);
void AI(float dt);
void misc(float dt); //do something (чисто чтоб нашкрести на 4 потока)

void notifyFinishFrame();

void finish();
void quit();

sf::Window Wnd;

bool running;

std::mutex mutIterationStarted;
std::condition_variable condNewIterationStarted;

std::mutex mutFinishedFrame;
std::condition_variable condFinishedFrame;
int finishedFrameNum;

#define THREADS_AMOUNT 1
bool threadReadyMap[THREADS_AMOUNT];

void init()
{
    setlocale(LC_ALL, "ru_RU.UTF-8");

    //WindowWidth  = GetSystemMetrics(SM_CXSCREEN);
    //WindowHeight = GetSystemMetrics(SM_CYSCREEN);
    int WindowWidth = GetSystemMetrics(SM_CXSCREEN) - 80;
    int WindowHeight = GetSystemMetrics(SM_CYSCREEN) - 15;

    Wnd.create(sf::VideoMode(WindowWidth, WindowHeight), "SNS 1.5 v0.0.1", sf::Style::Default, sf::ContextSettings(0, 0, 4));
    Wnd.setPosition(sf::Vector2i(80, 0));
    Wnd.setVerticalSyncEnabled(true);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR pCmdLine, int nShowCmd)
{
    init();

    running = true;
    std::thread threads[THREADS_AMOUNT] = {
  std::thread(action, std::ref(render), 0),
  //std::thread(action, std::ref(physics), 1),
  //std::thread(action, std::ref(AI), 2),
  //std::thread(action, std::ref(misc), 3),
    };

    while (running && Wnd.isOpen())
    {
  sf::Event event;
  while (Wnd.pollEvent(event))
  {
  }

  update(1/30.0);
    }

    finish();

    for (int i = 0; i < THREADS_AMOUNT; i++) {
  threads[i].join();
    }

    return 0;
}

void finish()
{
    {
  std::unique_lock<std::mutex> iterationLock(mutIterationStarted);
  running = false;
  condNewIterationStarted.notify_all();
    }

    Wnd.setMouseCursorVisible(true);
}

void quit() {
    std::unique_lock<std::mutex> iterationLock(mutIterationStarted);
    running = false;
}

void action(void(*func) (float), int mapId)
{
    while (true)
    {
  std::unique_lock<std::mutex> iterationLock(mutIterationStarted);
  bool exit = false;
  while (true) {
   condNewIterationStarted.wait(iterationLock);

   if (!running) {
    exit = true;
    break;
   }
   else if (threadReadyMap[mapId]) {
    threadReadyMap[mapId] = false;
    break;
   }
  }
  if (exit) break;

  func(1/30.0);
    }
}

void update(float dt)
{
    {
  std::unique_lock<std::mutex> iterationLock(mutIterationStarted);
  for (int i = 0; i < THREADS_AMOUNT; i++) {
   threadReadyMap[i] = true;
  }
  condNewIterationStarted.notify_all();
    }

    {
  std::unique_lock<std::mutex> frameLock(mutFinishedFrame);
  finishedFrameNum = 0;
  condFinishedFrame.wait(frameLock, []() { return finishedFrameNum == THREADS_AMOUNT; });
    }

    postUpdate(dt);
}

void postUpdate(float dt)
{
    static int a = 0;

    a++;
    if (a > 100000) {
  quit();
    }
}

void render(float dt)
{
    //do render

    notifyFinishFrame();
}

void physics(float dt)
{
    //do physics

    notifyFinishFrame();
}

void AI(float dt)
{
    //do AI

    notifyFinishFrame();
}

void misc(float dt)
{
    //do something

    notifyFinishFrame();
}

void notifyFinishFrame()
{
    std::unique_lock<std::mutex> frameLock(mutFinishedFrame);
    finishedFrameNum++;
    if (finishedFrameNum == THREADS_AMOUNT) {
  condFinishedFrame.notify_one();
    }
}

finishedFrameNum = 0;

for (int i = 0; i < THREADS_AMOUNT; i++) {
    std::unique_lock<std::mutex> iterationLock(mutIterationStarted[i]);
    threadReadyMap[i] = true;
    condIterationStarted[i].notify_one();
}

    
while (finishedFrameNum != THREADS_AMOUNT) {
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
}

postUpdate(dt);

void notifyFinishFrame()
{
    std::lock_guard<std::mutex> frameLock(mutFinishedFrame);
    finishedFrameNum++;
}

#include <Windows.h>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <SFML/Graphics.hpp>

void init();

void update(float dt);
void postUpdate(float dt);

void action(void(*func) (float), int mapId);

void render(float dt);
void physics(float dt);
void AI(float dt);
void misc(float dt); //do something

void notifyFinishFrame();

void finish();
void quit();

sf::Window Wnd;

bool running;

#define THREADS_AMOUNT 4
bool threadReadyMap[THREADS_AMOUNT];

std::mutex mutIterationStarted[THREADS_AMOUNT];
std::condition_variable condIterationStarted[THREADS_AMOUNT];

std::mutex mutFinishedFrame;
int finishedFrameNum;

void init()
{
    setlocale(LC_ALL, "ru_RU.UTF-8");

    //WindowWidth  = GetSystemMetrics(SM_CXSCREEN);
    //WindowHeight = GetSystemMetrics(SM_CYSCREEN);
    int WindowWidth = GetSystemMetrics(SM_CXSCREEN) - 80;
    int WindowHeight = GetSystemMetrics(SM_CYSCREEN) - 15;

    Wnd.create(sf::VideoMode(WindowWidth, WindowHeight), "SNS 1.5 v0.0.1", sf::Style::Default, sf::ContextSettings(0, 0, 4));
    Wnd.setPosition(sf::Vector2i(80, 0));
    Wnd.setVerticalSyncEnabled(true);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR pCmdLine, int nShowCmd)
{
    init();

    running = true;
    std::thread threads[THREADS_AMOUNT] = {
  std::thread(action, std::ref(render), 0),
  std::thread(action, std::ref(physics), 1),
  std::thread(action, std::ref(AI), 2),
  std::thread(action, std::ref(misc), 3),
    };

    while (running && Wnd.isOpen())
    {
  sf::Event event;
  while (Wnd.pollEvent(event))
  {
  }

  update(1/30.0);
    }

    finish();

    for (int i = 0; i < THREADS_AMOUNT; i++) {
  threads[i].detach();
    }

    return 0;
}

void finish()
{
    Wnd.setMouseCursorVisible(true);
}

void quit() {
    std::unique_lock<std::mutex> iterationLock[THREADS_AMOUNT] = {
  std::unique_lock<std::mutex>(mutIterationStarted[0]),
  std::unique_lock<std::mutex>(mutIterationStarted[1]),
  std::unique_lock<std::mutex>(mutIterationStarted[2]),
  std::unique_lock<std::mutex>(mutIterationStarted[3]),
    };
    running = false;
}

void action(void(*func) (float), int mapId)
{
    while (true)
    {
  std::unique_lock<std::mutex> iterationLock(mutIterationStarted[mapId]);
  bool exit = false;
  while (true) {
   condIterationStarted[mapId].wait(iterationLock);

   if (!running) {
    exit = true;
    break;
   }
   else if (threadReadyMap[mapId]) {
    threadReadyMap[mapId] = false;
    break;
   }
  }
  if (exit) break;

  func(1/30.0);
    }
}

void update(float dt)
{
    finishedFrameNum = 0;

    for (int i = 0; i < THREADS_AMOUNT; i++) {
  std::unique_lock<std::mutex> iterationLock(mutIterationStarted[i]);
  threadReadyMap[i] = true;
  condIterationStarted[i].notify_one();
    }

    
    while (finishedFrameNum != THREADS_AMOUNT) {
  std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }

    postUpdate(dt);
}

void postUpdate(float dt)
{
    static int a = 0;

    a++;
    if (a > 10000) {
  quit();
    }
}

void render(float dt)
{
    //do render
    int k = 6;
    for (int i = 0; i < 70000; i++) {
  k += i / 2;
    }

    notifyFinishFrame();
}

void physics(float dt)
{
    //do physics

    notifyFinishFrame();
}

void AI(float dt)
{
    //do AI

    notifyFinishFrame();
}

void misc(float dt)
{
    //do something

    notifyFinishFrame();
}

void notifyFinishFrame()
{
    std::lock_guard<std::mutex> frameLock(mutFinishedFrame);
    finishedFrameNum++;
}

#pragma once
#include <vector>
#include <mutex>
#include <thread>
#include <condition_variable>

typedef void(*threadingActionFunction) (float);

class Threading
{
public:
    void init(int threadsNum, threadingActionFunction postUpdate, int waitIntervalMicroseconds = 1000);
    void pushFunction(int threadId, threadingActionFunction func);
    void finalizeInitiation();
    void update(float deltaTime);
    void quit();

    Threading();
    ~Threading();

private:
    bool initiated_;

    std::vector<std::thread*> threads_;
    int threadsNum_;
    int waitIntervalMicroseconds_;
    float deltaTime_;
    std::vector<std::vector <threadingActionFunction> > functions_;
    threadingActionFunction postUpdateFunction_;

    std::vector<bool> threadReadyMap_;
    std::vector<std::mutex*> mutIterationStarted_;
    std::vector<std::condition_variable*> condIterationStarted_;
    std::mutex mutFinishedFrame_;
    int finishedFrameNum_;

    void action(int threadId);
    void notifyFinishFrame();

    inline int getThreadsNum() { return threadsNum_;    }
};

#include "Threading.h"

extern bool running;

Threading::Threading()
{
}

Threading::~Threading()
{
    quit();
}

void Threading::init(int threadsNum, threadingActionFunction postUpdate, int waitIntervalMicroseconds)
{
    threadsNum_ = threadsNum;
    postUpdateFunction_ = postUpdate;
    waitIntervalMicroseconds_ = waitIntervalMicroseconds;

    initiated_ = true;

    functions_.reserve( threadsNum_);
    threadReadyMap_.reserve( threadsNum_);
    mutIterationStarted_.reserve( threadsNum_);
    condIterationStarted_.reserve( threadsNum_);
    for (int i = 0; i < threadsNum_; i++) {
  functions_.emplace_back( std::vector <threadingActionFunction>() );
  threadReadyMap_.emplace_back(false);
  mutIterationStarted_.emplace_back( new std::mutex() );
  condIterationStarted_.emplace_back( new std::condition_variable() );
    }
}

void Threading::pushFunction(int threadId, threadingActionFunction func)
{
    functions_[threadId].push_back(func);
}

void Threading::finalizeInitiation()
{
    threads_.reserve(threadsNum_);
    for (int i = 0; i < threadsNum_; i++) {
  threads_.emplace_back( new std::thread(&Threading::action, this, i) );
    }
}

void Threading::update(float deltaTime)
{
    deltaTime_ = deltaTime;
    finishedFrameNum_ = 0;

    for (int i = 0; i < threadsNum_; i++) {
  std::unique_lock<std::mutex> iterationLock(*mutIterationStarted_[i]);
  threadReadyMap_[i] = true;
  condIterationStarted_[i]->notify_one();
    }

    while (finishedFrameNum_ != threadsNum_) {
  std::this_thread::sleep_for(std::chrono::microseconds(waitIntervalMicroseconds_));
    }

    postUpdateFunction_(deltaTime_);
}

void Threading::action(int threadId)
{
    while (true)
    {
  std::unique_lock<std::mutex> iterationLock(*mutIterationStarted_[threadId]);
  bool exit = false;
  while (true) {
   //wait for starting new game iteration
   condIterationStarted_[threadId]->wait(iterationLock);

   if (!running) {
    exit = true;
    break;
   }
   else if (threadReadyMap_[threadId]) {
    //to avoid spurious wakeup
    threadReadyMap_[threadId] = false;
    break;
   }
  }
  if (exit) break;

  //call all functions of the thread
  for (int i = 0; i < functions_[threadId].size(); i++) {
   functions_[threadId][i](deltaTime_);
  }

  //increase counter of threads that finished making this frame
  notifyFinishFrame();
    }
}

void Threading::notifyFinishFrame()
{
    std::lock_guard<std::mutex> frameLock(mutFinishedFrame_);
    finishedFrameNum_++;
}

void Threading::quit()
{
    if (!initiated_) {
  return;
    }
    initiated_ = false;

    for (int i = 0; i < threadsNum_; i++) {
  mutIterationStarted_[i]->lock();
    }

    running = false;

    for (int i = 0; i < threadsNum_; i++) {
  mutIterationStarted_[i]->unlock();
    }

    for (int i = 0; i < threadsNum_; i++) {
  condIterationStarted_[i]->notify_one();
    }

    for (int i = 0; i < threadsNum_; i++) {
  if (threads_[i]->joinable()) {
   threads_[i]->join();
  }

  delete threads_[i];
    }    
}

#include <Windows.h>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <SFML/Graphics.hpp>

#include "threading.h"

void init();

void render(float dt);
void physics(float dt);
void AI(float dt);
void misc(float dt); //do something

void postUpdate(float dt);

void finish();

sf::Window Wnd;
bool running;
float deltaTime;

Threading threading;

void init()
{
    setlocale(LC_ALL, "ru_RU.UTF-8");

    int WindowWidth = GetSystemMetrics(SM_CXSCREEN) - 80;
    int WindowHeight = GetSystemMetrics(SM_CYSCREEN) - 15;

    Wnd.create(sf::VideoMode(WindowWidth, WindowHeight), "SNS 1.5 v0.0.1", sf::Style::Default, sf::ContextSettings(0, 0, 4));
    Wnd.setPosition(sf::Vector2i(80, 0));
    Wnd.setVerticalSyncEnabled(true);

    deltaTime = 0.0;

    threading.init(4, postUpdate, 1500);

    threading.pushFunction(0, render);
    threading.pushFunction(1, physics);
    threading.pushFunction(2, AI);
    threading.pushFunction(3, misc);

    threading.finalizeInitiation();
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR pCmdLine, int nShowCmd)
{
    init();

    running = true;

    while (running && Wnd.isOpen())
    {
  sf::Event event;
  while (Wnd.pollEvent(event))
  {
  }

  deltaTime = 1.0 / 30;
  threading.update(deltaTime);
    }

    finish();

    return 0;
}

void finish()
{
    Wnd.setMouseCursorVisible(true);
}

void postUpdate(float dt)
{
    static int a;
    a++;
    if (a > 1000) {
  threading.quit();
    }
}

void render(float dt)
{
    int k = 0;
    for (int i = 0; i < 1000000; i++) {
  k++;
    }
}

void physics(float dt)
{
    int k = 0;
    for (int i = 0; i < 1000000; i++) {
  k++;
    }
}

void AI(float dt)
{
    int k = 0;
    for (int i = 0; i < 1000000; i++) {
  k++;
    }
}

void misc(float dt)
{
    int k = 0;
    for (int i = 0; i < 1000000; i++) {
  k++;
    }
}

for (int i = 0; i < threadsNum_; i++) {
  std::unique_lock<std::mutex> iterationLock(*mutIterationStarted_[i]);
  threadReadyMap_[i] = true;
  while (threadReadyMap_[i]) {
   condIterationStarted_[i]->notify_one();

   if (iterationLock.owns_lock()) {
    iterationLock.unlock();
   }
  }
    }