#include <iostream>
#include <thread>
#include <chrono>
#include <mutex>
#include <condition_variable>
#include <random>

using namespace std;

const int CZAS_PRACY = 5;
const int BUFFER_SIZE = 8;
const int LAST_INDEX = BUFFER_SIZE - 1;
const int INITIAL_INDEX = 0;
const int INITIAL_AMOUNT = 0;
const int NULL_VALUE = 0;

mutex mut;

template <typename TypDanych>
class Monitor
{
private:
    char bufferData[BUFFER_SIZE];
    int headIndex = INITIAL_INDEX;
    int tailIndex = INITIAL_INDEX;
    int bufferElements = INITIAL_AMOUNT;
    mutex mutexDane;
    condition_variable warunekSaNoweDane;
    condition_variable warunekZabranoDane;
public:
    Monitor()
    {
        bufferElements = 0;;
    }
    void zapisz(char data)
    {
        unique_lock<mutex> blokada(mutexDane);
        if(isFull()) warunekZabranoDane.wait(blokada);
         bufferData[tailIndex] = data;
        bufferElements ++;

        if(tailIndex == LAST_INDEX) {
            tailIndex = 0;
        } else {
            tailIndex ++;
        }
        warunekSaNoweDane.notify_one();
    }

    char odczytaj()
    {
        unique_lock<mutex> blokada(mutexDane);
        if(isEmpty()) warunekSaNoweDane.wait(blokada);
        char value = bufferData[headIndex];
        bufferData[headIndex] = NULL_VALUE;
        bufferElements --;

    if(headIndex == LAST_INDEX) {
        headIndex = 0;
    } else {
        headIndex ++;
    }
        warunekZabranoDane.notify_one();
        return value;
    }

    bool isFull() {
    return bufferElements == BUFFER_SIZE;
}

    bool isEmpty() {
    return bufferElements == 0;
    }
};

class Producent
{
private:
    int czas;
    Monitor< char >& pojemnik;
    char bierzacyZnak;
    int random;
    int nr;
    minstd_rand generator;
    uniform_int_distribution< char > rozklad;
public:
    Producent(Monitor < char > & _pojemnik, int _nr):
        czas(0), pojemnik(_pojemnik), bierzacyZnak('a'),
        generator(random_device()()), rozklad('a', 'z'), random(rand() % 5), nr(_nr)
    {
    }

    void operator()()
    {
        while (czas<CZAS_PRACY)
        {
            pojemnik.zapisz(bierzacyZnak);
            bierzacyZnak = (bierzacyZnak+1-97)%25+97;
            mut.lock();
            cout <<"Producent nr: "<<nr<<" znak: "<< bierzacyZnak << endl;
            //pojemnik.zapisz(rozklad(generator));
            mut.unlock();
            this_thread::sleep_for(chrono::seconds(random));
            ++czas;
        }
        pojemnik.zapisz(EOF);
    }

};

class Konsument
{
private:
    Monitor< char >& pojemnik;
    int nr;
public:
    Konsument(Monitor< char >& _pojemnik, int _nr):
        pojemnik(_pojemnik), nr(_nr) {}

    void operator()()
    {
        char znak=pojemnik.odczytaj();
        while(znak!=EOF)
        {
            mut.lock();
            cout <<"Konsument nr: "<<nr<<" znak: "<< znak << endl;
            mut.unlock();
            znak = pojemnik.odczytaj();
        }
    }
};
int main()
{
    random_device r;
    minstd_rand generator(r());
    Monitor< char > pojemnik;
    Konsument konsument(pojemnik, 1);
    Konsument konsument2(pojemnik, 2);
    Konsument konsument3(pojemnik, 3);
    Producent producent(pojemnik, 1);
    Producent producent2(pojemnik, 2);
    Producent producent3(pojemnik, 3);

    thread wk(konsument);
    thread wk2(konsument2);
    thread wk3(konsument3);
    thread wp(producent);
    thread wp2(producent2);
    thread wp3(producent3);
    wp.join();
    wk.join();
    wp2.join();
    wk2.join();
    wp3.join();
    wk3.join();
    return 0;
}