#define LINE_SIZE 100
#define LIST_SIZE 75
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>

// struktura pre pizzu; ma polozky pre nazov a cenu
struct pizza{
    char name[LINE_SIZE];
    float prize;
};

// pole pizz; ma maximalny pocet poloziek typu pizza podl'a macrosu
struct pizza list[LIST_SIZE];

// Funkcia pre nacitanie jednej pizzy, skopirovana z domacej ulohy 1.
int read_item(struct pizza *item) {
    //prve pomocne pole pre nacitanie nazovu 
    char line[LINE_SIZE];
    //druhe pomocne pole pre nacitanie ceny
    char line2[LINE_SIZE];
    //ked' nepodari nacitat' nazov - vrati 0
    if (!fgets(line, sizeof(line), stdin))
        return 0; 
    //ked' nacita prazdny nazov - vrati 0
    if (strlen(line) == 0)
        return 0; 
    //ked' nepodari nacitat' hodnotu ceny - vrati 0
    if (!fgets(line2, sizeof(line2), stdin))
        return 0; 
    // end pointer pre nacitanie pomocou strtof; ma referenciu na nastupny character po cilo s ciarou
    char *endptr;
    //nacitanie hodnoty cisla 
    float value = strtof(line2, &endptr);
// ked' nacitane cizlo zo standartneho vsutupu sa rovna nule, tak nacitat polozka pro pizzu nie je platne a vrati 0
    if (value == 0.0F)
        return 0; 
//prekopirujeme zo standartneho vstupu nazov v prvok nazov pizzy; operator -> pouzivame ked' mame referenciu na strukturu
    strcpy(item->name, line);
    item->prize = value;
// vrati 1 ked' polozku nacitalo
    return 1; 
}
// Funkcia pre nacitanie pol'a struktur typu pizza. V podstate je alternativou cycklusu while, ktory som pouzil v main du1
int read_pizza_list(struct pizza* list){
    // Initializujeme pocet  nacitanych poliziek
    int counter = 0;
    ///cycklus pre nacitanie
    for (int i = 0; i<LIST_SIZE; i++){
        //initializujeme v pamati jednu polozku typu  pizzu pomocou memset
        struct pizza item;
        memset(&item, 0, sizeof( struct pizza));
        // Skusame ju nacitat'; hodnota r musi byt' 1 ked' podarilo nacitat' standartny vstup
        int r = read_item(&item);
        // Ak nacitanlo spravne, vlozime polozku v pole struktur pomocu memcopy a zvacsime pocet nacitanych poloziek
        if(r){
            //memcpy ma za argumenty ma pointer kam musi prekopirovat', co a obsah; & v danom pripade pozuivame aby dostat' adresu
             memcpy(&list[i],&item,sizeof(struct pizza));
             counter++;
        }
        // Ak nepodari nacitiat polozku - vyjdeme zo slucky a vrati pocet nacitanych poloziek
        else{
            break;
        }
    }
    return counter;

}

// Pomozna funckia pre porovnanie dvoch poloziek typu pizzu. Pouzivame v qsort
int compare_pizza (const void *a, const void *b){
    //pracujeme z hodnotamy prize struktur a a b typu pizza
    float prize1 = ((struct pizza*)a)->prize;
    float prize2 = ((struct pizza*)b)->prize;
    // r2 - vysledok porovnavanie hodnot nazovov struktur; vyuzivame ked' dve polozky maju rovnaku cenu. 
    int r2 = strcmp(((struct pizza*)a)->name, ((struct pizza*)b)->name);
    //Initializujeme vysledok na 0 aby spravalo normalne bez nejakych neinitializovanych casti.
    /// r nemozeme initializovat' ako prize1 - prize 2 pretoze stratime informaciu pocas konvertacii float na int a qsort nebude spravat' spravne v niektorych pripadoch
    int r = 0;
    // Ked' pizza a ma mensiu hodnotu ceny ako b - musi ist' dopredu, preto pririadime hodnotu -1 vysledku r
    if (prize1 < prize2){
        r = -1;
        return r;
    }
    //naopak: musi ist' dozadu a pririadime 1 
     else if(prize1 > prize2){
        r = 1;
        return r;
    }
    // v inom pripade, cenu su rovnake a musime vratit' vysledok porovnavani nazovov.
    else{ return r2;}
}
int main(void){
    /// Pocet nacitanych poloziek listka a bude obsah, ktory potrebujeme  pri pouzitii quicksort
    int size= read_pizza_list(list);
//Pouzime quicksort 
   qsort(list, size, sizeof(struct pizza), compare_pizza);
   // Vypiseme listok
    for(int i = 0; i<size; i++){
        printf("%s%f\n", list[i].name, list[i].prize);
    }
    return 0;
}