#include <stdio.h>                                          //Pouzite kniznice
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

typedef struct pozicka {                                    //Struktura
    char sign[15];
    char isbn[17];
    char kniha[105];
    char autor[105];
    int datum;
    int cislo;
    struct pozicka *dalsi;                                  //smernik na dalsi
} POZICKA;

POZICKA * funkcia_n(POZICKA *p_prv, int *n) {               //Nacitanie zaznamov do zoznamu f vracia smernik na 1. zaznam
    if (p_prv != NULL) {                                    //ak smerník niekde ukazuje uvolni pamet
        free(p_prv);
    }
    FILE *fr;                                               //smernik typu file
    char nic[70], c;                                        //Deklaracia ukazovatela na smernik
    POZICKA *p_akt;                                         // deklarovany smernik na aktualny zaznam
    int x, i;
    *n = 0;

    fr = fopen("kniznica.txt", "r");                        //Otvorenie suboru na citanie
    if (fr == NULL) {                                       //Osetrenie neotvorenia suboru
        printf("Zaznamy neboli nacitane\n");
        return 0;
    }
    if ((c = fgetc(fr)) == '-') {
        while ((fgets(nic, 70, fr)) != NULL) {              //Citanie po riadkoch po koniec suboru
            fgets(nic, 70, fr);
            fgets(nic, 70, fr);
            fgets(nic, 70, fr);
            fgets(nic, 70, fr);
            fscanf(fr, "%d\n", &x);
            fscanf(fr, "%d\n", &x);
            (*n)++;                                         //Pocet zaznamov
        }

        if ((p_prv = (POZICKA *)malloc(sizeof(POZICKA))) == NULL) {         //smernik ukazuje na prvy vytvoreny zaznam
            printf("Malo pamate.\n");
            return 0;
        }

        rewind(fr);
        fgets(nic, 20, fr);
        fgets(p_prv->sign, 15, fr);                         // do prveho zaznamu sa ukladaju položky zo suboru
        fgets(p_prv->isbn, 17, fr);
        fgets(p_prv->kniha, 105, fr);
        fgets(p_prv->autor, 105, fr);
        fscanf(fr, "%d", &p_prv->datum);
        fscanf(fr, "%d", &p_prv->cislo);

        p_akt = p_prv;                                      //smernik aktualny ukazuje tam kde prvy

        for (i = 2; i <= *n; i++) {
            if ((p_akt->dalsi = (POZICKA *)malloc(sizeof(POZICKA))) == NULL) { //vytvorenie druheho zaznamu
                printf("Malo pamate.\n");
                return 0;
            }
            p_akt = p_akt->dalsi;                           // zabezpecuje prechadzanie zaznamom
            fgets(nic, 20, fr);
            fgets(nic, 20, fr);
            fgets(p_akt->sign, 15, fr);                     //do druheho zaznamu sa ukladaju polozky
            fgets(p_akt->isbn, 17, fr);
            fgets(p_akt->kniha, 105, fr);
            fgets(p_akt->autor, 105, fr);
            fscanf(fr, "%d", &p_akt->datum);
            fscanf(fr, "%d", &p_akt->cislo);
        }
        printf("Nacitalo sa %d zaznamov\n", *n);

        p_akt->dalsi = NULL;                                //priradi koniec zoznamu

        return p_prv;                                       // vrateny smernik na zaciatok zoznamu
    }
    return 0;
}
POZICKA * funkcia_v(POZICKA *p_prv) {                       //funkcia na vypis vracia smernik na aktualny zaznam
    if (p_prv != NULL) {

        POZICKA *p_akt;
        p_akt = p_prv;                                      //aktualny smernik ukazuje na prvy

        int x = 0;

        while (p_akt != NULL) {                             // pokial aktualny nieje na konci zoznamu
            printf("%d.\n", ++x);
            printf("signatura: %s", p_akt->sign);
            printf("isbn: %s", p_akt->isbn);
            printf("nazov: %s", p_akt->kniha);
            printf("autori: %s", p_akt->autor);
            printf("datum: %d\n", p_akt->datum);
            printf("preukaz: %d\n", p_akt->cislo);
            p_akt = p_akt->dalsi;
        }
        return p_akt;                                       // vrateny smernik na aktualny zaznam
    }
    return 0;
}
void funkcia_p(POZICKA **p_prv, int n) {                    // funkcia na pridanie zaznamu do zoznamu
    if (*p_prv != NULL) {
        POZICKA *p_nov, *p_akt;
        p_akt = *p_prv;

        int poz, i;

        scanf("%d ", &poz);
        if (poz > n) {
            poz = n + 1;

        }
        if ((p_nov = (POZICKA *)malloc(sizeof(POZICKA))) == NULL) {
            printf("Malo pamate.\n");
            return;
        }
        fgets(p_nov->sign, 15, stdin);                      //nacitavanie hodnot do zaznamu
        fgets(p_nov->isbn, 17, stdin);
        fgets(p_nov->kniha, 105, stdin);
        fgets(p_nov->autor, 105, stdin);
        scanf("%d\n", &p_nov->datum);
        scanf("%d\n", &p_nov->cislo);
        if (poz > 1) {                                      //pridavanie na prvu poziciu
            for (i = 1; i < poz - 1; i++) {
                p_akt = p_akt->dalsi;
            }
            p_nov->dalsi = p_akt->dalsi;
            p_akt->dalsi = p_nov;
        }
        else {                                              //pridanie na poziciu
            p_nov->dalsi = *p_prv;
            *p_prv = p_nov;
        }
    }
}

void funkcia_z(POZICKA **p_prv) {                           //funkcia kt vymazuje zvolene zaznamy zo zoznamu podla autora
    char pole[30];
    scanf("%s", pole);
    if (*p_prv == NULL) {
        printf("Vymazalo sa 0 zaznamov\n");
        return;
    }
    POZICKA *p_akt, *p_pre, *pom;                           //deklaracie
    p_akt = *p_prv;                                         //p_akt ukazuje tam kde p_prv

    char kvk[150];
    int i = 0, poc = 0;

    while (pole[i] != '\0') {
        pole[i] = tolower(pole[i]);                         //vsetky pismena podretazca male
        i++;
    }
    i = 0;

    while (p_akt != NULL) {                                 //pokial nieje koniec zoznamu
        strcpy(kvk, p_akt->autor);                          //do pola kvk skopiruj autora z aktualneho zaznamu
        while (kvk[i] != '\0') {
            kvk[i] = tolower(kvk[i]);                       //vsetky pismena podretazca male
            i++;
        }
        i = 0;
        if (strstr(kvk, pole) == NULL) {                    //ak sa podretazec nenachadza v kvk prejdi na dalsi zaznam
            p_akt = p_akt->dalsi;
            continue;
        }
        if (p_akt == *p_prv) {                              //ak odstanujem prvy zaznam
            pom = *p_prv;                                   //smernik p_prv ulozeny do pomocnej
            *p_prv = (*p_prv)->dalsi;                       //smernik prv ukazuje na dalsi zaznam
            p_akt = *p_prv;                                 //aktualny ukazuje na prvy
            free(pom);                                      //odstranenie prveho zaznamu
            poc++;
        }
        else{
            p_pre = *p_prv;                                 //predchadzajuci ukazuje na prvy
            while (p_pre->dalsi != p_akt) {                 //najdenie zaznamu na vymazanie
                p_pre = p_pre->dalsi;                       // prechadzanie na dalsi zaznam
            }
            p_pre->dalsi = p_akt->dalsi;

            pom = p_akt;
            p_akt = p_akt->dalsi;
            free(pom);                                      //odstranie zaznamu
            poc++;
        }
    }
    printf("Vymazalo sa %d zaznamov\n", poc);
}

void funkcia_h(POZICKA *p_prv) {                            //funkcia hlada pozicky podla cisla preukazu a vypise ich
    int cis;
    scanf("%d", &cis);
    if (p_prv == NULL) {
        printf("Pre dane cislo preukazu neevidujeme vypozicky\n");
        return;
    }
    int x = 0;

    POZICKA *p_akt;                                         //deklaracia smerniku typu pozicka
    p_akt = p_prv;                                          //p_prv a p_akt ukazuju na rovnake miesto

    while (p_akt != NULL) {
        if (p_akt->cislo == cis) {
            printf("%d.\n", ++x);                           //vypis najdenych poli
            printf("signatura: %s", p_akt->sign);
            printf("isbn: %s", p_akt->isbn);
            printf("nazov: %s", p_akt->kniha);
            printf("autori: %s", p_akt->autor);
            printf("datum: %d\n", p_akt->datum);
            printf("preukaz: %d\n", p_akt->cislo);

        }
        p_akt = p_akt->dalsi;                               //prechadzanie na dalsi zaznam
    }
}

void funkcia_a(POZICKA *p_prv) {                            //aktualizacia podla datumu
    int dat;
    scanf("%d", &dat);
    if (p_prv == NULL) {
        printf("Aktualizovalo sa 0 zaznamov\n");
        return;
    }
    int pom, help, poc = 0;

    POZICKA *p_akt;                                         //deklaracia smerniku typu pozicka
    p_akt = p_prv;

    while (p_akt != NULL) {
        if ((p_akt->datum) <= dat) {
            poc++;
            pom = p_akt->datum;
            help = pom % 10000;
            pom = pom / 10000;
            pom = pom + 1;                                  //pripocitanie jednotky ku roku z datumu
            pom = pom * 10000;
            pom = pom + help;
            p_akt->datum = pom;

        }
        p_akt = p_akt->dalsi;                               //prechadzanie na dalsi zaznam
    }
    printf("Aktualizovalo sa %d zaznamov\n", poc);
}

int main() {
    int n;
    char volba;
    POZICKA *p_prv = NULL, *p_akt = NULL, *pom;             //deklaracie smernikov typu pozicka
    do {
        volba = getchar();
        switch (volba) {
        case 'n': p_prv = funkcia_n(p_prv, &n); break;      //Volanie funkcii
        case 'v': p_akt = funkcia_v(p_prv); break;
        case 'p': funkcia_p(&p_prv, n); break;
        case 'z': funkcia_z(&p_prv); break;
        case 'h': funkcia_h(p_prv); break;
        case 'a': funkcia_a(p_prv); break;
        }
    } while (volba != 'k');
    p_akt = p_prv;
    while (p_akt != NULL) {                                 //uvolnenie zaznamu
        pom = p_akt;
        p_akt = p_akt->dalsi;
        free(pom);
    }
    return 0;
}