#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <errno.h>

int semafor;
key_t klucz;

char *adres_pamieci;
int pamiec;
key_t klucz_pamieci;

int odlaczenie1, odlaczenie2;



static void utworz_klucz_semafora(void)
 {
        klucz = ftok(".",'v');

        if(klucz == -1)
        {
                printf("Blad tworzenia klucza (producent)\n");
                exit(-1);
        }
        else
                printf("Zoastal utworzony klucz: %d (producent)\n", klucz);
}

static void utworz_nowy_semafor(void)
{
        semafor=semget(klucz, 2, 0666|IPC_CREAT);
        if (semafor==-1)
        {
                printf("Nie moglem utworzyc nowego semafora /producent.\n");
                exit(EXIT_FAILURE);
        }
        else
        {
                printf("Semafor zostal utworzony : %d /producent\n",semafor);
        }
  }

static void ustaw_semafor(int sem, int na)
{
        int ustaw_sem;
        ustaw_sem = semctl(semafor, sem, SETVAL, na);
        if(ustaw_sem==-1)
        {
                printf("Nie mozna ustawic semafora.\n");
                exit(EXIT_FAILURE);
        }
        else
        {
                printf("Semafor zostal ustawiony.\n");
        }

}


static void semafor_v(int nr)
 { int zmien_sem;
        struct sembuf bufor_sem;
        bufor_sem.sem_num=nr;
        bufor_sem.sem_op=1;
        bufor_sem.sem_flg=0;

        while(1)
        {
                zmien_sem=semop(semafor, &bufor_sem,1);
                if(zmien_sem == 0 || errno != 4)
                        break;
        }

        if (zmien_sem==-1)
        {

                printf("Nie moglem otworzyc semafora.\n");
                exit(EXIT_FAILURE);
        }
        else
        {
                printf("Semafor zostal otwarty.\n");
        }
  }

static void semafor_p(int nr)
 {
        int zmien_sem;
        struct sembuf bufor_sem;
        bufor_sem.sem_num = nr;
        bufor_sem.sem_op = -1;
        bufor_sem.sem_flg = 0;

        while(1)
        { //100
                zmien_sem = semop(semafor, &bufor_sem, 1);
                if(zmien_sem == 0 || errno != 4)
                        break;
        }
        if(zmien_sem == -1)
        {
                printf("Nie moglem zamknac semafora.\n");
                exit(EXIT_FAILURE);
        }
        else
        {
                printf("Semafor zostal zamkniety.\n");
        }

 }

static void usun_semafor(void)
{
        int sem;
        sem = semctl(semafor, 0, IPC_RMID);
        if(sem == -1)
        {
                printf("Nie mozna usunac semafora.\n");
                exit(EXIT_FAILURE);
        }
        else
        {
                printf("Semafor zostal usuniety: %d\n");
        }
}
static void utworz_klucz_pamieci_dzielonej(void)
{
        klucz_pamieci = ftok(".",'V');

        if(klucz_pamieci == -1)
        {
                printf("Blad tworzenia klucza (producent)\n");
                exit(-1);
        }
        else
                printf("Zoastal utworzony klucz: %d (producent)\n", klucz_pamieci);
}

static void utworz_nowy_segment_pamieci(void)
{
         pamiec = shmget(klucz_pamieci, sizeof(char), IPC_CREAT  | 0666);

        if(pamiec == -1)
        {
                printf("Problemy z utworzeniem pamieci dzielonej./producent \n");
                exit(EXIT_FAILURE);
        }
        else
                printf("Pamiec dzielona zostala utworzona:/producent %d\n",pamiec);


        adres_pamieci = (char *) shmat(pamiec, 0, 0);
        if(adres_pamieci == NULL && errno != 0)
        {
                printf("Nie mozna uzyskac adresu segmentu pamieci. /producent \n");
                exit(EXIT_FAILURE);
        }
        else printf("Uzyskano adres segmentu pamieci. /producent \n");
}

static void odlacz_pamiec(void)
 {
    odlaczenie1=shmctl(pamiec,IPC_RMID,0);
    odlaczenie2=shmdt(adres_pamieci);
    if (odlaczenie1==-1 || odlaczenie2==-1)
      {
        printf("Problemy z odlaczeniem pamieci dzielonej.\n");
        exit(EXIT_FAILURE);
      }
    else printf("Pamiec dzielona zostala odlaczona.\n");
  }
int main()
{

        char znak;
        FILE *wejscie;

        utworz_klucz_pamieci_dzielonej();
        utworz_nowy_segment_pamieci();
        utworz_klucz_semafora();
        utworz_nowy_semafor();
        ustaw_semafor(0,1);
        ustaw_semafor(1,0);
 wejscie = fopen("wejscie", "r");

        if(wejscie == NULL)
        {
                printf("Nie mozna otworzyc pliku wejscie dla odczytu /producent\n");
                exit(EXIT_FAILURE);
        }
        else
        {
                while(!feof(wejscie))
                {
                        znak = fgetc(wejscie);

                        if(znak != EOF)
                        {
                        semafor_p(0);

                        *adres_pamieci = znak;
                        printf("Znak = %c, adres pamiec = %c /producent\n",znak,*adres_pamieci);

                        semafor_v(1);
                        //sleep(1);
                        }

                }


        semafor_p(0);

        *adres_pamieci = EOF;

        semafor_v(1);
        }


        fclose(wejscie);

        //usun_semafor();
        //odlacz_pamiec();
        return 0;
}