#include <iostream>
#include <string.h>
#include <pthread.h>
#include <sstream>
#include <vector>
#include <time.h>
#include <unistd.h>
#include <cstdint>
#define UNUSED(expr) do { (void)(expr); } while (0)
#define NEEDTOWRITE 1
#define NEEDTOREAD 2
#define END 1
#define NOTEND 2
#define INIT 1
#define NOTINIT 2
using namespace std;

int isDebug = 0;
int stat = NEEDTOWRITE;
int isEnd = NOTEND;
pthread_mutex_t numbMutex;
pthread_mutex_t consumerMutex;
pthread_mutex_t consumerMutex1;
pthread_cond_t needToReadCond, needToWriteCond;
long long int numb;
void* producer_routine(void* arg) {
    UNUSED(arg);
    // Wait for consumer to start
    // vector<string>& result = *reinterpret_cast<vector<string>*>(arg);
    string line;
    getline(cin, line);
    istringstream iss(line);
    vector<string> result;
    for(string s;iss>>s;)
        result.push_back(s);
    int n=result.size();
    for(int i=0;i<n;i++){
        pthread_mutex_lock(&numbMutex);
        while (stat!=NEEDTOWRITE){
            pthread_cond_wait(&needToWriteCond,&numbMutex);
        }
        numb = stoll(result[i]);
        stat = NEEDTOREAD;
        pthread_cond_signal(&needToReadCond);

        pthread_mutex_unlock(&numbMutex);
    }
    pthread_cond_broadcast(&needToReadCond);
    isEnd = END;
    stat = NEEDTOREAD;
    pthread_cond_broadcast(&needToReadCond);
    // Read data, loop through each value and update the value, notify consumer, wait for consumer to process
    return nullptr;
}

void* consumer_routine(void* arg) {
    // notify about start
    // for every update issued by producer, read the value and add to sum
    // return pointer to result (for particular consumer)
    long long int local_result = 0;
    int sleep = *reinterpret_cast<int*>(arg);

    UNUSED(arg);
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
     do{

        pthread_mutex_lock(&consumerMutex);

        while (stat != NEEDTOREAD ) {
            cout << "fdsfsd0" << endl;

            pthread_cond_wait(&needToReadCond, &consumerMutex);
        }
        local_result += numb;
        stat = NEEDTOWRITE;
        pthread_cond_signal(&needToWriteCond);
        pthread_mutex_unlock(&consumerMutex);
        cout << "fdsfsd" << endl;
        if (sleep > 0) {
            cout << "fdsfsd2" << endl;
            int sleep_millis = (rand() % sleep) + 1;
            UNUSED(sleep_millis);
            usleep(sleep_millis * 1000);
            cout << "fdsfsd3" << endl;
        }
         cout << "fdsfsd4" << endl;
        cout << isEnd << endl;
    }while(isEnd != END);
    cout << "fdsfsd5" << endl;


    pthread_mutex_lock(&consumerMutex);
    pthread_cond_signal(&needToReadCond);
    pthread_mutex_unlock(&consumerMutex);
    cout << "fdsfsd6" << endl;
    return (void *) local_result;
}

void* consumer_interruptor_routine(void* arg) {
    // wait for consumers to start

    // interrupt random consumer while producer is running
    UNUSED(arg);

    return nullptr;
}

int run_threads(long long int threadsCount, int waitCount) {
    // start N threads and wait until they're done
    // return aggregated sum of values
    long long int result  = 0 ;
    if(threadsCount < 1) return 0;
    if(threadsCount == 0){
        return 0;
    }
    pthread_t producer, interrupter;
    UNUSED(interrupter);
    UNUSED(waitCount);
    vector <pthread_t> consumers;
    //int n=result.size();
    pthread_create( &producer, NULL, producer_routine, NULL);
    for (int i = 0; i < threadsCount; i++) {
        pthread_t consumer;
        pthread_create(&consumer, NULL, consumer_routine, &waitCount);
        consumers.push_back(consumer);
    }
    for (int i = 0; i < threadsCount; i++) {
        long long int partial = 0;
        pthread_join(consumers[i], (void **) &partial);
        result += partial;
    }
    pthread_join( producer, NULL);
    return result;
}

int get_tid() {
    // 1 to 3+N thread ID


    return 0;
}
int init(){
    pthread_mutex_init(&numbMutex, NULL);
    pthread_mutex_init(&consumerMutex, NULL);
    pthread_mutex_init(&consumerMutex1, NULL);
    pthread_cond_init(&needToReadCond, NULL);
    pthread_cond_init(&needToWriteCond, NULL);
    return 0;
}
int end(){
    pthread_mutex_destroy(&numbMutex);
    pthread_mutex_destroy(&consumerMutex);
    pthread_mutex_destroy(&consumerMutex1);
    pthread_cond_destroy(&needToReadCond);
    pthread_cond_destroy(&needToWriteCond);
    return 0;
}

int main(int argc, char *argv[]) {
    srand(time(NULL));
    init();
    long long int threadsCount = atoll(argv[1]);
    int waitCount  = atoi(argv[2]);
    if(argc > 3){
        if(strcmp(argv[3],"–debug"))
            isDebug = 1;
    }
    std::cout << run_threads(threadsCount, waitCount) << std::endl;
    end();
    return 0;
}