// INFORMACJE Z INTERNETU:
// If O_NONBLOCK is set, an open() for reading-only shall return without delay.
// An open() for writing-only shall return an error if no process currently has the file open for reading.
// EBADF Ost odczyt Koniec danych po zamnknieciu


#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/wait.h>

// ./konsument [ilosc konsumentow]

////////////// ZMIENNE GLOBALNE ///////////////////

int pid;
int potok;
int liczbaKonsumentow;

unsigned int limitProcesow;
char limitProcesowUzytkownika[10];
char uruchomioneProcesyUzytkownika[10];
FILE *limitFile;

FILE *fp;
char sciezkaPliku[50] = "./konsumenci/";
char charpid[10];
char znak;
char bufor;

//////////////////////////////// MAIN ////////////////////////////////
int main(int argc, char *argv[]) {

    //# PORZĄDKOWANIE ARGUMENTÓW:
    if (argc != 2) {
        printf("ERROR KONSUMENT: Nieprawidlowa liczba argumentow\n");
        exit(1);
    }

    if (argv[1] <= 0){
        printf("ERROR: Liczba Konsumentów powinna być liczbą dodatnią\n");
        exit(-1);
    }

    liczbaKonsumentow = atoi(argv[1]);

    //# LIMIT PROCESÓW UŻYTKOWNIKA:
    if (system("./limity.sh") == -1) {
        printf("ERROR: Błąd zbierania informacji o limitach!\n");
        exit(-1);
    }

    limitFile = fopen("limity.txt", "r");
    if (limitFile == NULL) {
        printf("ERROR: Błąd otwierania pliku!\n");
        exit(-1);
    }

    fgets(limitProcesowUzytkownika, 10, limitFile);             //# printf("!%d!",atoi(limitProcesowUzytkownika));
    fgets(uruchomioneProcesyUzytkownika, 10, limitFile);        //# printf("!%d!",atoi(uruchomioneProcesyUzytkownika));
    limitProcesow = atoi(limitProcesowUzytkownika)- atoi(uruchomioneProcesyUzytkownika);

    if (fclose(limitFile) == -1) {
        printf("ERROR: Zamykanie pliku!");
        exit(-1);
    }

    if (limitProcesow <= liczbaKonsumentow) {
        printf("ERROR: Nie mozna utworzyć tylu procesow!\n");
        exit(-1);
    }

    //# TWORZENIE KONSUMENTÓW:
    for (int j = 1; j < liczbaKonsumentow; ++j) {

        if ((pid = fork()) < 0) {
            perror("ERROR KONSUMENT: fork ");
            exit(1);
        } else if (pid != 0) {
            break;
        }
    }

    //# PRZYGOTOWANIE PLIKU DO ZAPISU:
    sprintf(charpid, "%d", getpid());
    strcat(sciezkaPliku, charpid);

    fp = fopen(sciezkaPliku, "w");

    if (fp == NULL) {
        perror("ERROR KONSUMENT: fopen ");
        exit(1);
    }

    //# PRZYGOTOWANIE POTOKU FIFO:
    potok = open("./tmp/TST", O_RDONLY | O_NONBLOCK); //tylko do odczytu;

    if (potok == -1) {
        perror("ERROR KONSUMENT: open ");
        exit(1);
    }

    //# CZYTANIE Z POTOKU:
    sleep(10);
    while (1) {

        ssize_t retval = read(potok, &bufor, sizeof(bufor));

        //# OSTATNI ODCZYT Z POTOKU
        if (retval <= 0) {
            if (retval == -1){
                perror("ERROR: Błąd czytanie z potoku - KONSUMENT");
                break;
                //puts("A TU KONCZY!\n");
                //exit(-1);

            } else {
                //puts("B TU KONCZY!\n");
                break;
            }
        }

        printf("%c", bufor);
        fprintf(fp, "%c", bufor);
        fflush(stdin);
    }

    puts("TTUTTAAJJ!\n");
    if (close(potok) == -1) {
        perror("ERROR: Błąd zamykania potoku - KONSUMENT");
        exit(-1);
    }

    if (fclose(fp) == -1) {
        perror("ERROR: Błąd zamykania pliku - KONSUMENT");
        exit(-1);
    }

    int waitStatus;
    if (wait(&waitStatus) == -1) {
        perror("ERROR: Błąd czekania na procesy potomne - KONSUMENT");
        exit(-1);
    }

    //puts("C TU KONCZY!\n");
    return 0;
}