typedef struct mmbr {
            valueType value;
            struct mmbr *next;
        } member;

typedef struct {
    member *a;
    member *b;
} queue; 

/**
 * Head file for queue operations
 *
 * @file queue.h 
 * @author   A.  Zlamal
 * @version 2020 04 17  
 * 
 */


/**
 *  Inicialize the given queue.
 *  
 *  Inicializuje zadanou frontu.
 *
 *  @param[in, out]  s  the address of the queue to inicialize.
 *                      adresa fronty, jenz se ma inicialisovat.
 *                      
 *  @param[in]  sz  the size of the queue to inicialize. 
 *                  IN CASE OF IMPLEMENTATION BY LINKED LIST DATA OF SIZE IS OMITTED.
 *                  velikost fronty, jez se ma inicialisovat.
 *                  V PRIPADE IMPLEMENTACE SPOJOVYM SEZNAMEM SE UDAJ VELIKOSTI OPOMIJI.
 */
void inicialisuj(queue *q, unsigned int sz);

/**
 *  Enqueue the value of the second parametr to the queue pointed by the first parametr.
 *  Vlozi hodnotu druheho parametru do fronty zadane prvním parametrem.   
 *
 *  @param[in, out]  s  the address of the queue, into which is to be enqueued.
 *                      adresa fronty, do niz se ma vlozit.
 *   
 *  @param[in]  pv  the value, which is to enqueueue.
 *                  hodnota jenz se se ma vlozit.
 *  IMPORTANT WARNING: REACTION ON THE ENQUEUE TO FULL QUEUE IS NOT DEFINED
 *                     AND WITH HIGH PROBABILITY CAUSES FATAL ERROR.
 *                     BEFORE ENQUEUE TEST THE QUEUE BY FUNCTION queueIsFull.
 *   (Remark: there is the posibility to join queueIsFull and enqueue
 *               int enqueueNew(queue q, valueType *pv){
 *                   if(queueIsFull(q){
 *                       return 1;
 *                   }
 *                   enqueue(q, pv);
 *                   return 0;
 *               }, but I decided for the introduced variant.)
 *  DURAZNE UPOZORNENI: REAKCE NA VLOZENI DO PLNE FRONTY NENI DEFINOVANA
 *                      A S VYSOKOU PRAVDEPODOBNOSTI POVEDE K OSUDOVE CHYBE.
 *                      PRED VKLADANIM OTESTUJTE FRONTU FUNKCI queueIsFull.
 *   (Poznamka: je mozne spojit queueIsFull a enqueue
 *               int enqueueNew(queue q, valueType *pv){
 *                   if(queueIsFull(q){
 *                       return 1;
 *                   }
 *                   enqueue(q, pv);
 *                   return 0;
 *               }, ale rozhodl jsem se pro predstavenou variantu.)
 */
void vloz(queue *q, valueType *pv);

/**
 *  Dequeue the value, which is on the dequeue end of the queue. 
 *  Vrati hodnotu, jez je na odebiracim konci zasobniku. 
 *
 *  @param[in, out]  s  the address of the queue, from which is to dequeueue the value.
 *                      adresa fronty, z niz se se ma odebrat hodnota.
 *  
 *  @param[out]  pv  the value, which is dequeued.
 *                    hodnota, ktera se ma odebrat.
 *
 *  IMPORTANT WARNING: REACTION ON THE DEQUEUEING FROM EMPTY QUEUE IS NOT DEFINED
 *                     AND WITH HIGH PROBABILITY CAUSES FATAL ERRORR.
 *                     BEFORE DEQUEUE TEST THE QUEUE BY FUNCTION queueIsEmpty.
 *   (Remark: there is the posibility to join queueIsEmpty and dequeue
 *               int dequeueNew(queue q, valueType *pv){
 *                   if(queueIsEmpty(q){
 *                       return 1;
 *                   }
 *                   dequeue(q, pv);
 *                   return 0;
 *               }, but I decided for the introduced variant.)
 *  DURAZNE UPOZORNENI: REAKCE NA ODKAZ NA VYJMUTI Z PRAZDNE FRONTY NENI DEFINOVANA
 *                      A S VYSOKOU PRAVDEPODOBNOSTI POVEDE K OSUDOVE CHYBE.
 *                      PRED VYBEREM OTESTUJTE FRONTU FUNKCI queueIsEmpty.
 *   (Poznamka: je mozne spojit queueIsEmpty a dequeue
 *               int enqueueNew(queue q, valueType *pv){
 *                   if(queueIsEmpty(q){
 *                       return 1;
 *                   }
 *                   dequeue(q, pv);
 *                   return 0;
 *               }, ale rozhodl jsem se pro predstavenou variantu.)
 */
void vyjmi(queue *q, valueType *pv);

/**
 *  Returns the the value, which is to dequeue.
 *  Vrati hodnotu, ktera se ma odebrat z fronty. 
 *
 *  @param[in, out]  s  the address of the queue, from which is to be copied the value from dequeueing end.
 *                      adresa zasobniku, z jehoz odebiraciho konce se ma zkopirovat hodnota.
 *  
 *  @param[out]  pv  the address, into which is to store the value, which is on the dequeueing end.
 *                   adresa, na niz se ma hodnota z jejiho odebiraciho konce ulozit.
 *
 *  IMPORTANT WARNING: REACTION ON THE REFERENCING THE TOP FROM EMPTY QUEUE IS NOT DEFINED
 *                     AND WITH HIGH PROBABILITY CAUSES FATAL ERROR.
 *                     BEFORE USING FRONT TEST THE QUEUE BY FUNCTION queueIsEmpty.
 *   (Remark: there is too the posibility to join queueIsEmpty and front
 *               int frontNew(queue q, valueType *pv){
 *                   if(queueIsEmpty(q){
 *                       return 1;
 *                   }
 *                   frontNew(q, pv);
 *                   return 0;
 *               }, but I decided for the introduced variant.)
 *  DURAZNE UPOZORNENI: REAKCE NA ODKAZ NA VRCHOL PRAZDNEHO FRONTY NENI DEFINOVANA
 *                      A S VYSOKOU PRAVDEPODOBNOSTI POVEDE K OSUDOVE CHYBE.
 *                      PRED REFERENCOVANIM ODEBIRACIHO KONCE OTESTUJTE ZASOBNIK FUNKCI queueIsEmpty.
 *   (Poznamka: je mozne spojit queueIsEmpty a front
 *               int frontNew(queue q, valueType *pv){
 *                   if(queueIsEmpty(q){
 *                       return 1;
 *                   }
 *                   front(q, pv);
 *                   return 0;
 *               }, ale rozhodl jsem se pro predstavenou variantu.)
 */
void naVyjmuti(queue *q, valueType *pv);

/**
 *  Tests if the queue is empty.
 *  Testuje zda je fronta prazdna. 
 *   
 *  @param[in, out]  s  the address of the queue.
 *                      adresa fronty.
 *   
 *  @return  non zero iff the queue is empty; otherwise zero.
 *           nenulovou hodnotu, jen je-li fronta prazdna; v opacnem pripade nulu. 
 */
int jePrazdna(queue *q);

/**
 *  Tests if the queue is full 
 *  Testuje zda je fronta plna.  
 *
 *  @param[in, out]  s  the address of the queue.
 *                      adresa fronty.
 *   
 *  @return  zero iff the stack isn't full; otherwise non zero.
 *           nulu jen neni-li zasobnik plny; v opacnem pripade nenulovou hodnotu.
 */
int jePlna(queue *q);

/**
 *  Free the memory allocated for the queue in case of implentation by linked list.
 *                  (The same effect as initialize, but without memory leaks tested by valgrind.)
 *  Uvolni pamet alokovanou pro frontu v pripade implementace spojovym seznamem.
 *                  (Stejny efekt jako inicialisuj, ale bez memory leaku zjistovanych valgrindem.)
 *   
 *  @param[in, out]  q  address of the queue.
 *                      adresa fronty.
 */
void uvolniPamet(queue *q);

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "definedTypeForArray.h"
#include "queue.h"

/**
 * Program to demonstrate functions for queue 
 * 
 * @file   main.c 
 * @author   A.  Zlamal
 * @version 2020 04 17  
 */
int main(){
    valueType y;
    queue f;
    int isf;
    char *formStr = "Fronta je plna: hodnota %s se uz nevesla.\n";  

    inicialisuj(&f, 8); 
    printf("Zadavejte na radky znakove retezce. Ta se budou vkladat do fronty.\n"
           "Zadavani se ukoncuje prazdnym radkem.\n");
    while ((fgets(y, TEXT_LENGTH, stdin) != NULL) && (*y != '\n') && !(isf = jePlna(&f))) {
        y[strlen(y) - 1] = '\0';
        vloz(&f, &y);
    }
    if (isf) {
        y[strlen(y) - 1] = '\0';
        printf(formStr, y);
    }
    printf("Konec vkladani do fronty a nejvyse dvakrat vyber z ni.\n");
    if (!jePrazdna(&f)) {
        naVyjmuti(&f, &y);
        printf("    %s :: ", y);
        vyjmi(&f, &y);
        printf("%s\n", y);
    }
    if (!jePrazdna(&f)) {
        naVyjmuti(&f, &y);
        printf("    %s :: ", y);
        vyjmi(&f, &y);
        printf("%s\n", y);
    }
    printf("Nasleduje dalsi vkladani do fronty a vyber vseho z ni:\n");
    while ((fgets(y, TEXT_LENGTH, stdin) != NULL) && (*y != '\n') && !(isf = jePlna(&f))) {
        y[strlen(y) - 1] = '\0';
        vloz(&f, &y);
    }
    if (isf) {
        y[strlen(y) - 1] = '\0';
        printf(formStr, y);
    }
    while (!jePrazdna(&f)) {
        naVyjmuti(&f, &y);
        printf("    %s :: ", y);
        vyjmi(&f, &y);
        printf("%s\n", y);
    }
    printf("\nNasleduje dalsi vkladani do fronty a opet vyber vseho z ni:\n");
    while ((fgets(y, TEXT_LENGTH, stdin) != NULL) && (*y != '\n') && !(isf = jePlna(&f))) {
        y[strlen(y) - 1] = '\0';
        y[strlen(y) - 1] = '\0';
        vloz(&f, &y);
    }
    if (isf) {
        printf(formStr, y);
    }
    while (!jePrazdna(&f)) {
        naVyjmuti(&f, &y);
        printf("    %s :: ", y);
        vyjmi(&f, &y);
        printf("%s\n", y);
    }
    uvolniPamet(&f);
    printf("Byla uvolnena pamet zasobniku: %s.\nKonec chodu programu.\n", f == NULL ? "NULL" : f->values[0]);
    return EXIT_SUCCESS;
}