/* Milutin Aleksic, Dragutin Ostojic, 2022 */

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
#include<stdlib.h>

typedef struct lista
{
    int br;
    struct lista *next;
} lista;

int listaMax, brojRadnika, brojDana;
int currentLista = 0;

lista *posao;


int Insert(int value)
{
    if(currentLista < listaMax)
    {
        lista *pom = posao;

        lista *novi = (lista*)malloc(sizeof(lista));
        novi->br = value;
        novi->next = posao;

        if(pom == NULL)
        {
            novi->next = novi;
            posao = novi;
            currentLista++;
            return 1;
        }

        while(pom->next != posao)
        {
            pom = pom->next;
        }
            

        pom->next = novi;
        currentLista++;

        return 1;
    }

    return -1;
    
}

int Search(int index)
{
    if(index < currentLista)
    {
        lista *pom = posao;

        while(index--)
        {
            pom = pom->next;
        }

        return pom->br;
    }

    return -1;
}

int Delete(int index)
{
    if(index < currentLista)
    {
        lista *pom = posao;

        if(index == 0)
        {
            while(pom->next != posao)
                pom = pom->next;

            lista *temp = posao;
            
            posao = posao->next;
            pom->next = posao;
            currentLista--;

            free(temp);

            return 1;
        }

        index--;

        while(index--)
        {
            pom = pom->next;
        }

        lista *temp = pom->next;
        pom->next = temp->next;
        free(temp);
        currentLista--;

        return 1;

    }

    return -1;
}

pthread_mutex_t listaLock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t listaCond = PTHREAD_COND_INITIALIZER;

int brisu = 0, citaju = 0, upisuju = 0;

int SyncSearch(long id, int index)
{
    pthread_mutex_lock(&listaLock);
    while(brisu > 0)
        pthread_cond_wait(&listaCond, &listaLock);
    citaju++;
    printf("IZVRSAVANJE: Radnik %ld naredba CITANJE - %d\n", id, index);
    pthread_mutex_unlock(&listaLock);
    int res = Search(index);

    pthread_mutex_lock(&listaLock);
    citaju--;
    pthread_cond_broadcast(&listaCond);
    pthread_mutex_unlock(&listaLock);

    return res;
}

int SyncInsert(long id, int value)
{
    pthread_mutex_lock(&listaLock);
    while(brisu > 0 && upisuju > 0)
        pthread_cond_wait(&listaCond, &listaLock);
    upisuju++;
    printf("IZVRSAVANJE: Radnik %ld naredba UPISIVANJE - %d\n", id, value);
    pthread_mutex_unlock(&listaLock);

    int res = Insert(value);

    pthread_mutex_lock(&listaLock);
    upisuju--;
    pthread_mutex_unlock(&listaLock);

    return res;
}

int SyncDelete(long id, int index)
{
    pthread_mutex_lock(&listaLock);
    while(brisu > 0 && upisuju > 0 && citaju > 0)
        pthread_cond_wait(&listaCond, &listaLock);
    brisu++;
    printf("IZVRSAVANJE: Radnik %ld naredba BRISANJE - %d\n", id, index);
    pthread_mutex_unlock(&listaLock);

    int res = Delete(index);

    pthread_mutex_lock(&listaLock);
    brisu--;
    pthread_mutex_unlock(&listaLock);

    return res;
}


pthread_mutex_t prijava;
pthread_barrier_t cekanjePrijave;

#define CITANJE 0
#define UPISIVANJE 1
#define BRISANJE 2

int *poslovi, *argumenti;
int brojPrijavljenih = 0;

char nazivi[3][12] = {"CITANJE", "UPISIVANJE", "BRISANJE"}; 

void* Manager(void* t)
{   
    
    for(int i=0;i<brojDana;i++)
    {
        pthread_barrier_wait(&cekanjePrijave);

        printf("Manger pocinje sa radom u danu %d\n", i);

        for(int j=0;j<brojRadnika;j++)
        {
            poslovi[j] = rand() % 3;

            if(poslovi[j] == UPISIVANJE)
                argumenti[j] = rand() % 10000;
            else
                argumenti[j] = rand() % listaMax;
        }
            

        pthread_barrier_wait(&cekanjePrijave);
    }
}

void* Worker(void* t)
{
    long tid = (long)t;

    for(int i=0;i<brojDana;i++)
    {
        brojPrijavljenih++;

        // prijava
        pthread_barrier_wait(&cekanjePrijave);
        // dodeljivanje zadataka
        pthread_barrier_wait(&cekanjePrijave);      

        printf("ZAHTEV: Radnik %ld, naredba %s, %d\n", tid, nazivi[poslovi[tid]], argumenti[tid]);

        int res;

        switch (poslovi[tid])
        {
        case CITANJE:
            res = SyncSearch(tid, argumenti[tid]);
            if(res == -1)
                printf("NEUSPEH: Radnik %ld naredba %s - %d, lista %d\n", tid, nazivi[poslovi[tid]], argumenti[tid], currentLista);
            else
                printf("USPEH: Radnik %ld naredba %s - %d\n", tid, nazivi[poslovi[tid]], argumenti[tid]);
            break;

        case UPISIVANJE:
            res = SyncInsert(tid, argumenti[tid]);
            if(res == -1)
                printf("NEUSPEH: Radnik %ld naredba %s - %d, lista %d\n", tid, nazivi[poslovi[tid]], argumenti[tid], currentLista);
            else
                printf("USPEH: Radnik %ld naredba %s - %d\n", tid, nazivi[poslovi[tid]], argumenti[tid]);
            break;
            
        case BRISANJE:
            res = SyncDelete(tid, argumenti[tid]);
            if(res == -1)
                printf("NEUSPEH: Radnik %ld naredba %s - %d, lista %d\n", tid, nazivi[poslovi[tid]], argumenti[tid], currentLista);
            else
                printf("USPEH: Radnik %ld naredba %s - %d\n", tid, nazivi[poslovi[tid]], argumenti[tid]);
            break;
        
        default:
            break;
        }
    }
}

int main()
{
    srand(0);

    printf("Unos\n");
    scanf("%d%d%d", &brojRadnika, &listaMax, &brojDana);

    pthread_t threads[brojRadnika+1];
    poslovi = (int*)malloc(brojRadnika*sizeof(int));
    argumenti = (int*)malloc(brojRadnika*sizeof(int));

    Insert(0);
    Insert(1);

    pthread_mutex_init(&prijava, NULL);
    pthread_barrier_init(&cekanjePrijave, NULL, brojRadnika+1);

    for(long i=0;i<brojRadnika;i++)
        pthread_create(&threads[i], NULL, Worker, (void*) i);

    pthread_create(&threads[brojRadnika], NULL, Manager, (void*) 0);


    pthread_exit(NULL);
}