//1:
int prefix( const char * test, const char * str) {
   int i, len = strlen(test);

   for ( i = 0; i < len; i++ )
   {
       //char toupper(char c)   - vstupom je kopia znaku, vystupom je znak skonvertovany na velke
       //                          (znak c sa teda nemeni)
       //    ked na oba znaky aplikujeme toupper, tak dostaneme case-insensitive porovnanie
       if (toupper(test[i]) != toupper(str[i])
           return 0;            //ak sa niekde lisia, tak uz to nie je prefix (predpona)
   }
   //kedze vnutri je return, mozeme strlen(str) ignorovat:
   //  ak sa dojde na koniec, bude tam '\0', a v test-e bude nieco ine
   //ak by sa to riesilo inak, musi sa kontrolovat, ci sa neprekroci strlen(str)

   //vsade sa zhodli, cize je to predpona
   return 1;
}
//2:
typedef struct {
 char nazov[31];   //30 znakov + ukoncovaci
 int id;
 double cena;
} Tovar;

Tovar* najdi_najlacnejsi( Tovar sklad[], int pocet ) {
   int i;

   //prvy tovar je potencialne najlacnejsi
   Tovar * lacny = &sklad[0];

   //syntax: * patri k typu: premenna s nazvom lacny ma typ Tovar*,
   //                         uklada sa do nej adresa nejakeho tovaru
   //          AKEHO: pouzijeme & na zistenie adresy prveho prvku pola

   for ( i = 1 ; i < pocet ; i++ )
   {
       //ak najdeme nieco lacnejsie:
       if (lacny->cena > sklad[i].cena)
           lacny = &sklad[i];

       //zmenime ulozenu adresu
   }

   return lacny;
}
//3:
// keby nebol tovar smernik (vstup by bol Tovar tovar), tak by sme zmenili len lokalnu kopiu
// ak je novy nazov dlhsi ako 30, hrozi pretecenie (prepiseme v pamati, co nemame), v tomto rieseni sa zahodia znaky navyse
void zmen_nazov( Tovar *tovar, const char* novy_nazov) {
   strncpy (tovar->nazov, novy_nazov, 30);
   tovar->nazov[30] = '\0';    //strncpy neda ukoncovaci znak, ak urezal retazec, preto pridame '\0'
}
//4:
Tovar* najdi_text( Tovar sklad[], int pocet, const char* dopyt) {
   int i, j, len;

   //pre kazdy tovar na sklade
   for ( i = 0 ; i < pocet ; i++ )
   {
       //priklad: dopyt = "retaz", nazov = "podretazec"
       //hladame v ramci textu "podretazec", "odretazec", "dretazec", "retazec" --- toto zacina "retaz", mame ho

       len = strlen(sklad[i].nazov) - strlen(dopyt);   //nema zmysel testovat viac j-cok

       for (j = 0 ; j <= len ; j++)                    // <= lebo aj cely retazec nech testuje
       {
           //ak je dopyt prefixom nejakej casti, tak sme to nasli
           if (prefix(dopyt, sklad[i].nazov + j))
               return &sklad[i];                  //vratime adresu, prvy mozny

           // + j   : vyuzivam smernikovu aritmetiku, mohol som dat aj &sklad[i].nazov[j]
           // &sklad[i]   : operator &, pouzivany uz od prvej prednasky bol nejaky nepopularny na skuske
           //               ked neviete napisat &, dalo sa aj: sklad + i
       }
   }
   //nic sa nenaslo:
   return NULL;
}
//5:
void vypis( FILE * f, Tovar sklad[], int pocet, const char* dopyt) {
   //f je vyssie otvoreny subor, cize ziadne fopen/fclose nerobit

   Tovar * tovar;

   //najdieme prvy tovar cez najdi text:
   tovar = najdi_text(sklad, pocet, dopyt);

   while ( tovar != NULL )
   {
       //ak je najdeny nejaky tovar, vypiseme ho
       fprintf( f, "%i, %s, %.2lf\n",
            tovar->id, tovar->nazov, tovar->cena);

       //skusime najst dalsi z nich
         // zaciname hned za najdenym tovarom: tovar+1
         // pocet musime tiez zmenit, kolko sa ma este prehladat?
         //                  koniec = sklad + pocet
         // teraz sme na     tovar + 1
         // ma sa prehladat: koniec - (tovar + 1)
         // po uprave, druhy argument
       tovar = najdi_text(tovar+1, sklad + pocet - tovar - 1, dopyt);
   }

}
//6:
int nacitaj_subor( char * subor, Tovar sklad[], int max) {
   int pocet;

   //subor je zadany menom, cize si musime pripravit smernik na FILE strukturu, subor otvorit
   FILE * f;

   f = fopen(subor, "r");
   if (f == NULL)    //ak sa nepodari otvorit, koncime
       return -1;

   //citame maximalne max poloziek
   for ( pocet = 0; pocet < max; pocet++ )
   {
       //a ak nieco nevieme precitat skor, tak skoncime skor
       if (!nacitaj(f, &sklad[pocet]))
           break;
   }
   //caste chyby: ak zlyhala nacitaj, tak sa pokracovalo v nacitavani
   //    ale to vytvaralo "diery" v poli

   fclose(f);
   return pocet;
}
//7:
typedef struct {
    Tovar * tovar;
    int mnozstvo;    //standardny kosik: kolko kusov tovaru (vid dalsia uloha)
}  Objednavka;

double suma( Objednavka objednavky[], int pocet) {
   int i;
   double sum;  //cena je double, tak aj suma musi byt

   //trivialny cyklus
   for ( i = 0 ; i < pocet ; i++ )
   {
       sum += objednavky[i].tovar->cena * objednavky[i].mnozstvo;

       // bodka a sipka sa vzdy tyka toho, co je vlavo
       //  rozhodujeme sa podla typu:
       //  objednavky[i]       ma typ Objednavka, co je struktura, teda je za tym .
       //  objednavky[i].tovar ma typ Tovar*, co je smernik na strukturu, teda je za tym ->


   }


   return sum;
}
//8:
Objednavka* pridaj( Objednavka* pole, int *dlzka, Tovar *tovar) {
   int i, len = *dlzka;
   for ( i = 0; i < len; i++ )
   {
       //najprv sa pozrieme, ci uz sme taky tovar objednavali
       if (pole[i].tovar->id == tovar->id) {

           //ak ano, len priratame pocet kusov
           pole[i].mnozstvo++;

           //tu treba hned skoncit, vsetko je vybavene
           return pole;
       }
   }

   //taky tovar sme este nemali, predlzme pole objednavok a pridajme tam 1 kus:
   len++;
   pole = (Objednavka*) realloc(pole, sizeof(Objednavka)*len);
   pole[len-1].tovar = tovar;     //premenna tovar je uz smernik, cize obsahuje adresu, tu len prekopirujeme do objednavky
   pole[len-1].mnozstvo = 1;      //doplnime pocet

   //zaktualizujeme dlzku a vratime novu adresu pola objednavok
   *dlzka = len;
   return pole;
}