#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <pthread.h>
#include <stdbool.h>
#include <values.h>
#include <stdlib.h>
#include <time.h>

struct Parameters {
    int left;
    int right;
    int size;
    int *max_printed_number;
    int *amount_of_working_threads;
};


const int max_memory_size = 100000;
const int limit = INT_MAX - 1;
const int retries = 1;


int min(int a, int b) {
    if (a < b) {
        return a;
    }
    return b;
}


int max(int a, int b) {
    if (a < b) {
        return b;
    }
    return a;
}


int myCeil(int numerator, int denominator) {
    return (numerator - 1) / denominator + 1;
}


void * eratosphen_iteration(void* vp) {
    struct Parameters* p = (struct Parameters*)vp;
    int segment_size = p->right - p->left + 1;
    bool* new_segment = (bool*) malloc(sizeof(bool) * segment_size);
    // за число k отвечает индекс k - p->left;
    for (int i = 0; i < segment_size; ++i) {
        new_segment[i] = true;
    }
    int j = 0;
    for (int i = 2; i * i <= p->size; ++i) {
        j = myCeil(p->left, i) * i - p->left;
        for (; j <= segment_size; j += i) {
            if (j + p->left != i) {
                new_segment[j] = false;
            }
        }
    }
    printf("With %d-start thread is waiting on 1 place\n", p->left);
    while ((*(p->max_printed_number)) + 1 != p->left) {
        //wait
        if (p->left != 51) {
            printf("With %d-start thread is waiting\n", p->left);
        }
    }
    printf("With %d-start thread is ready\n", p->left);
    for (int i = 0; i < segment_size; ++i) {
        if (new_segment[i]) {
            printf("%d\n", i + p->left);
        }
    }
    free(new_segment);
    *(p->max_printed_number) = p->right;
    (*(p->amount_of_working_threads))--;
}

//Есть проблема, если n < threadsNum
void eratosphenus(int threads_num, int n) {
    int max_thread_memory = myCeil(min(max_memory_size, n), threads_num);
    pthread_t *threads = (pthread_t *) malloc(sizeof(pthread_t) * myCeil(n, max_thread_memory));
    int max_printed_number = 0;
    int amount_of_working_threads = 0;
    int max_given_number = 0;
    int next_max_given_number = 0;
    int next_free_thread = 0;
    while (max_given_number < n) {
        if (amount_of_working_threads < threads_num) {
            next_max_given_number = min(max_thread_memory + max_given_number, n);
            struct Parameters new_parameter = {max_given_number + 1, next_max_given_number, n, &max_printed_number, &amount_of_working_threads};
            printf("created %d thread from %d to %d\n", next_free_thread + 1, new_parameter.left, new_parameter.right);
            printf("%p\n", &new_parameter);
            //pthread_create(threads + next_free_thread, NULL, eratosphen_iteration, &new_parameter);
            pthread_create(threads + next_free_thread, NULL, eratosphen_iteration, (void*)new_parameter); // AZAAZ
            amount_of_working_threads++;
            next_free_thread++;
            max_given_number = next_max_given_number;
        }
    }
    for (int i = 0; i < next_free_thread; ++i) {
        pthread_join(threads[i], NULL);
    }
    free(threads);
}


int main(int argc, char** argv) {
    int n = 0;
    if (argc == 2) {
        n = limit;
    }
    else {
        n = atoi(argv[2]);
    }
    //clock_t start, end;
    //start = clock();
    for (int i = 0; i < retries; ++i) {
        eratosphenus(atoi(argv[1]), n);
    }
    //end = clock();
    //printf("%f seconds", (float)(end- start)/retries/CLOCKS_PER_SEC);
    return 0;
}