#include <iostream>
#include <atomic>
#include <mutex>
#include <thread>

struct Data
{
    Data( int* pBuf ) : m_pBuf( pBuf )
    {}

    int* m_pBuf = nullptr;
    bool m_empty = true;
    std::mutex m_mutex;
};

void Produce( std::atomic<bool>& stopFlag, Data* data )
{
    std::cout << "Produce initialization..." << std::endl;

    int numbers = 10;
    uint32_t done_counter = 0;

    while( !stopFlag )
    {
        auto& curr_data = data[done_counter % 2];
        std::unique_lock lock( curr_data.m_mutex );
        if( !curr_data.m_empty )
        {
            lock.unlock();
            // busy wait
            std::this_thread::sleep_for( std::chrono::microseconds( 10 ));
            continue;
        }

        std::this_thread::sleep_for( std::chrono::milliseconds( rand() % 100 ));
        curr_data.m_pBuf[0] = ++numbers;
        curr_data.m_empty = false;

        done_counter++;

        std::cout << "Produce next " << numbers << std::endl;
    }

    std::cout << "Produce finish" << std::endl;
}

int main()
{
    srand( 1024 );

    int buf[2] = {0}; // Two buffers
    uint32_t done_counter = 0; // buffers proccessed
    std::atomic<bool> stopFlag = false;
    Data data[2] = { buf, buf + 1 };

    auto produceTh = std::thread( Produce, std::ref( stopFlag ), data );

    // Work with swap buffers
    while( !stopFlag )
    {
        auto& curr_data = data[done_counter % 2];

        std::unique_lock lock( curr_data.m_mutex );
        if( curr_data.m_empty )
        {
            lock.unlock();
            // busy wait
            std::this_thread::sleep_for( std::chrono::microseconds( 10 ));
            continue;
        }

        auto& curr_buff = buf[done_counter % 2];
        // use data in buffer
        std::cout << "Get produce result with value "
                  << curr_buff << std::endl;

        curr_data.m_empty = true;
        done_counter++;

        if( curr_buff > 50 )
            stopFlag = true;
    }

    produceTh.join();

    std::cout << "The end" << std::endl;
    return 0;
}

///
class Producer
{
public:
    Producer(int initVal)
        : m_numbers(initVal)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(100 + rand() % 1000));
    }

    int Generate()
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(rand() % 100));
        return ++m_numbers;
    }
    int Value()
    {
        return m_numbers;
    }

private:
    int m_numbers = 0;
};

///
int main()
{
    srand(1024);

    int buf[2] = { 0 }; // Two buffers
    size_t currInd = 0; // Current ready buffer index

    std::cout << "Produce initialization..." << std::endl;
    Producer prod(10);
    buf[0] = prod.Generate();

    ///
    struct Produce
    {
        Produce(Producer* prod)
            : m_prod(prod)
        {}

        bool operator()(int* buf)
        {
            *buf = m_prod->Generate();
            std::cout << "Produce next " << m_prod->Value() << std::endl;
            return true;
        }

        Producer* m_prod = nullptr;
    };
    Produce prodFunc(&prod);

    // Work with swap buffers
    for (;;)
    {
        std::future<bool> answer = std::async(std::launch::async, std::ref(prodFunc), (currInd ? &buf[0] : &buf[1]));

        auto resNumber = buf[currInd];
        std::cout << "Read prev result " << resNumber << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(rand() % 100));
        std::cout << "Process prev result " << resNumber << std::endl;

        currInd = currInd ? 0 : 1;
        answer.wait();
        std::cout << "Get produce result " << answer.get() << " with value " << buf[currInd] << std::endl;

        if (buf[currInd] > 50)
        {
            break;
        }
    }

    std::cout << "The end" << std::endl;
    return 0;
}