#include <stdio.h>
#include <stdlib.h>
#include<string.h>

typedef struct dadoteka_st{
    char naziv[50];
    int brojBlokova;
}dadoteka;
typedef struct nastavaUSkoli_st{
    char evidencioniBroj[7];
    char naslovNastavneJedinice[51];
    char date[20];
    int brojPrisutnihucenika;
}nastavaUSkoli;
typedef struct promena_st{
    nastavaUSkoli data;
    int akcija; //0 brisanje 1 dodavanje 2 izmena
}promena;
typedef struct blok_st{
    int popunjenost; //kada se doda novi clan popunjenost se povecava
    promena nizPromena[5]; //faktor blokiranje je pet
}blok;
typedef struct node_st{
    promena data;
    struct promena_st * next;
}node;
void insert(node ** lista, promena pr){
    node * tmp = (node*)malloc(sizeof(node));
    tmp->data.akcija = pr.akcija;
    tmp->data.data.brojPrisutnihucenika = pr.data.brojPrisutnihucenika;
    strcpy(tmp->data.data.date,pr.data.date);
    strcpy(tmp->data.data.evidencioniBroj,pr.data.evidencioniBroj);
    strcpy(tmp->data.data.naslovNastavneJedinice,pr.data.naslovNastavneJedinice);
    tmp->next = NULL;
    if(*lista == NULL){
        *lista = tmp;
        return;
    }
    node * it = *lista;
    while(it->next != NULL){
        it = it->next;
    }
    it->next = tmp;
}
void printPromena(promena pr){
    printf("%d %s %s %s %d\n",pr.akcija,pr.data.evidencioniBroj,pr.data.naslovNastavneJedinice,pr.data.date,pr.data.brojPrisutnihucenika);
}
void printList(node * tmp){
    if(tmp == NULL){
        printf("Lista je prazna\n");
        return;
    }
    while(tmp != NULL){
        printPromena(tmp->data);
        tmp = tmp->next;
    }
}
static const promena praznaPromena;
void initBlok(blok * mojBlok){
    mojBlok->popunjenost = 0;
    for(int i=0;i<5;i++){
        mojBlok->nizPromena[i] = praznaPromena;
    }

}
void swap(promena * p1, promena * p2){
    promena tmp;
    tmp = *p1;
    *p1 = *p2;
    *p2 = tmp;
}
void sortList(node * tmp){
    node * itI = tmp;
    node * itJ = tmp;
    while(itI != NULL){
        itJ = itI;
        while(itJ != NULL){
            if(strcmp(itI->data.data.evidencioniBroj,itJ->data.data.evidencioniBroj) >= 0){
                swap(&itI->data,&itJ->data);
            }
            itJ = itJ->next;
        }
        itI = itI->next;
    }
}
void populateSecvential(node ** head){
    FILE * dummyUlaz = fopen("C:\\Users\\mihajlo\\praviProjekat\\cmake-build-debug\\CMakeFiles\\praviProjekat.dir\\ulaz.in","r");
    if(dummyUlaz == NULL){
        printf("greska pri otvaranju ulaznog fajla");
        return;
    }
    * head = NULL;
    promena promena1;
    while(fscanf(dummyUlaz,"%d %s %s %s %d",&promena1.akcija,promena1.data.evidencioniBroj,promena1.data.naslovNastavneJedinice,promena1.data.date,&promena1.data.brojPrisutnihucenika) != EOF){
        insert(head,promena1);
    }
    fclose(dummyUlaz);
}
void dodajListuSerijska(node * head){
    FILE * serijskiFajl = fopen("ulaz.bin","wb+");
    if(head == NULL){
        printf("Lista je prazna, nema sta da se doda u serijsku");
        return;
    }
    int i=0;
    blok blok1;
    initBlok(&blok1);
    while(head != NULL){
        blok1.nizPromena[i] = head->data;
        blok1.popunjenost++;
        if(i==4){
            fwrite(&blok1, sizeof(blok), 1, serijskiFajl);
            initBlok(&blok1);
            i=0;
            head = head->next;
            continue;
        }
        i++;
        head = head->next;
    }
    if(blok1.popunjenost != 0){
        fwrite(&blok1, sizeof(blok), 1, serijskiFajl);
    }
    fclose(serijskiFajl);
}
void printBlok(blok blok1){
    printf("Popunjenost bloka: %d\n", blok1.popunjenost);
    for(int i=0;i<blok1.popunjenost;i++){
        printPromena(blok1.nizPromena[i]);//baca segmentation
    }
}
void printBinarnaDadoteka(dadoteka ulaznaDadoteka){
    printf("Naziv dadoteke: %s\n",ulaznaDadoteka.naziv);
    printf("Broj blokova: %d\n",ulaznaDadoteka.brojBlokova);
    FILE * serijskiFajl = fopen(ulaznaDadoteka.naziv,"rb");
    if(serijskiFajl == NULL){
        printf("Neuspesno otvaranje aktivne dadoteke za ispis");
        return;
    }
    blok pr;
    for(int i=0;i<ulaznaDadoteka.brojBlokova;i++){
        fread(&pr, sizeof(blok),1, serijskiFajl);
        printBlok(pr);
    }
    fclose(serijskiFajl);
}
void delete(){
    FILE * serijskiFajl = fopen("ulaz.bin","wb");
    fclose(serijskiFajl);
}
void insertDataIzlazna(dadoteka * ulazna,dadoteka * izlazna){
    FILE * ulaznaDadoteka = fopen(ulazna->naziv,"rb+");
    FILE * izlaznaSekv = fopen(izlazna->naziv,"wb");
    if(izlaznaSekv == NULL){
        printf("Neuspesno otvaranje izlazne sekv dadoteke");
    }
    izlazna->brojBlokova = ulazna->brojBlokova;
    blok p;
    for(int i=0;i<=ulazna->brojBlokova;i++){
        fread(&p, sizeof(blok),1,ulaznaDadoteka);
        fwrite(&p, sizeof(blok),1,izlaznaSekv);
    }
    fclose(ulaznaDadoteka);
    fclose(izlaznaSekv);
}
int prvoCitanje=0;
int izvisiIzmenuDodavanja(dadoteka * ulaznaDadoteka,dadoteka * izlaznaDadoteka, promena p){
    FILE * serijskiFajl = fopen(ulaznaDadoteka->naziv,"rb");
    FILE * izlazniFajl = fopen(izlaznaDadoteka->naziv,"wb+");
    if(serijskiFajl == NULL){
        printf("Neuspesno otvaranje aktivne dadoteke za ispis u dodavanju");
        return -1;
    }
    izlaznaDadoteka->brojBlokova = 0;
    blok pr;
    initBlok(&pr);
    int i;
    for(i=0;i<ulaznaDadoteka->brojBlokova;i++){
        fread(&pr, sizeof(blok),1, serijskiFajl);
        for(int j=0;j<pr.popunjenost;j++){
            if(strcmp(pr.nizPromena[j].data.evidencioniBroj,p.data.evidencioniBroj) == 0){
                printf("\n***ERROR: Greska, slog sa istim indetifikacionm kljucem vec postoji***\n");
                return -1;
            }//treba dodati da se prekida pretraga kada se predje velicina tog indetifikacionog kljuca
            pr.nizPromena[j].akcija = 1;
        }
        fwrite(&pr, sizeof(blok),1,izlazniFajl);
        izlaznaDadoteka->brojBlokova++;
    }
    if(prvoCitanje == 1){
        fread(&pr, sizeof(blok),1, serijskiFajl);
    }
    prvoCitanje = 1;
    if(pr.popunjenost == 5){
        for(int j=0;j<pr.popunjenost;j++){
            if(strcmp(pr.nizPromena[j].data.evidencioniBroj,p.data.evidencioniBroj) == 0){
                printf("\n***ERROR: Greska, slog sa istim indetifikacionm kljucem vec postoji***\n");
                return -1;
            }//treba dodati da se prekida pretraga kada se predje velicina tog indetifikacionog kljuca
            pr.nizPromena[j].akcija = 1;
        }
        fwrite(&pr, sizeof(blok),1,izlazniFajl);
        izlaznaDadoteka->brojBlokova++;
        initBlok(&pr);
        pr.nizPromena[0] = p;
        pr.popunjenost++;
        pr.nizPromena[0].akcija = 1;
        fwrite(&pr, sizeof(blok),1,izlazniFajl);
    }else{
        for(int j=0;j<pr.popunjenost;j++){
            if(strcmp(pr.nizPromena[j].data.evidencioniBroj,p.data.evidencioniBroj) == 0){
                printf("\n***ERROR: Greska, slog sa istim indetifikacionm kljucem vec postoji***\n");
                return -1;
            }//treba dodati da se prekida pretraga kada se predje velicina tog indetifikacionog kljuca
            pr.nizPromena[j].akcija = 1;
        }
        pr.nizPromena[pr.popunjenost] = p;
        pr.nizPromena[0].akcija = 1;
        pr.popunjenost++;
        fseek(izlazniFajl, sizeof(blok) * izlaznaDadoteka->brojBlokova,SEEK_SET);
        fwrite(&pr, sizeof(blok),1,izlazniFajl);
    }
    fclose(izlazniFajl);
    fclose(serijskiFajl);
    return 1;
}
int izvrsiIzmenuLogickoBrisanje(dadoteka * ulaznaDadoteka, promena p){
    int lokacijaBlok;
    if(traziBlok(*ulaznaDadoteka,p) == -1){
        printf("\n** ERROR: Neuspesno trazenje sloga pri logickom birsanju: ");
        printPromena(p);
        printf("Podaci: \n");
        printBinarnaDadoteka(*ulaznaDadoteka);
        return -1;
    }
    printf("\n*****************************\n");
    printf("Uspesno obrisan slog: ");
    printPromena(p);
    printf("Fajl pre brisanja:\n");
    printBinarnaDadoteka(*ulaznaDadoteka);
    FILE * ulazniFajl = fopen(ulaznaDadoteka->naziv,"rb+");
    fseek(ulazniFajl, sizeof(lokacijaBlok) * lokacijaBlok, SEEK_SET);
    blok b;
    fread(&b, sizeof(blok),1,ulazniFajl);//blok u kojem se nalazi trazeni podatak je ucitan
    for(int i=0;i<b.popunjenost;i++){
        if(strcmp(b.nizPromena[i].data.evidencioniBroj,p.data.evidencioniBroj) == 0){
            b.nizPromena[i].akcija = 0;//ovo znaci da je izbrisan
        }
    }

    fseek(ulazniFajl, sizeof(blok) * lokacijaBlok, SEEK_SET);
    fwrite(&b, sizeof(blok),1,ulazniFajl);
    if(ulazniFajl == NULL){
        printf("Neuspesno otvaranje aktivne dadoteke za ispis u dodavanju");
        return -1;
    }
    fclose(ulazniFajl);
    printf("Fajl posle brisanja:\n");
    printBinarnaDadoteka(*ulaznaDadoteka);
    printf("\n*******************************\n");
    return 1;
}
void formirajSekvencijalnu(dadoteka * dadotekaIzmena,dadoteka * izlaznaSekvencijalnaDadoteka){
    FILE * fileDadotekaIzmena = fopen(dadotekaIzmena->naziv,"rb");
    dadoteka pomocna;
    initDadoteka("pomocna.bin", &pomocna);
    if(fileDadotekaIzmena == NULL){
        printf("Neuspesno otvaranje aktivne dadoteke za ispis");
        return;
    }
    blok pr;
    for(int i=0;i<dadotekaIzmena->brojBlokova;i++){
        fread(&pr, sizeof(blok),1, fileDadotekaIzmena);
        for(int j=0;j<pr.popunjenost;j++){
            if(pr.nizPromena[j].akcija == 1){
                if(izvisiIzmenuDodavanja(izlaznaSekvencijalnaDadoteka,&pomocna, pr.nizPromena[j]) == -1) continue;
                insertDataIzlazna(&pomocna,izlaznaSekvencijalnaDadoteka);
            }
            if(pr.nizPromena[j].akcija == 0){
                izvrsiIzmenuLogickoBrisanje(izlaznaSekvencijalnaDadoteka,pr.nizPromena[j]);
            }
        }
    }
    izlaznaSekvencijalnaDadoteka->brojBlokova++;
    fclose(fileDadotekaIzmena);
}
int traziBlok(dadoteka ulazna,promena p){
    blok pr;
    FILE * ulaznaDadoteka = fopen(ulazna.naziv,"rb");
    for(int i=0;i<ulazna.brojBlokova;i++){
        fread(&pr, sizeof(blok),1, ulaznaDadoteka);
        for(int j=0;j<pr.popunjenost;j++){
            if(strcmp(pr.nizPromena[j].data.evidencioniBroj,p.data.evidencioniBroj) == 0){
                return i;
            }
        }
    }
    return -1;
}
void updateDadoteka(dadoteka * ulaznaDadoteka){
    FILE * serijskiFajl = fopen(ulaznaDadoteka->naziv,"rb");
    if(serijskiFajl == NULL){
        printf("Neuspesno otvaranje aktivne dadoteke za ispis");
        return;
    }
    blok pr;
    while(fread(&pr, sizeof(blok),1, serijskiFajl) != NULL){
        ulaznaDadoteka->brojBlokova++;
    }
    fclose(serijskiFajl);
}
void initDadoteka(char ulaznaDadotekaNaziv[], dadoteka * ulaznaDadoteka){
    strcpy(ulaznaDadoteka->naziv,ulaznaDadotekaNaziv);
    ulaznaDadoteka->brojBlokova = 0;
}
int main() {
    node * head;
    dadoteka dadoteka1;
    dadoteka dadotekaIzlazna;
    initDadoteka("ulaz.bin", &dadoteka1);
    initDadoteka("mizlazna.bin", &dadotekaIzlazna);
    delete();
    populateSecvential(&head);
    sortList(head);
    dodajListuSerijska(head);
    updateDadoteka(&dadoteka1);
    formirajSekvencijalnu(&dadoteka1, &dadotekaIzlazna);
    printBinarnaDadoteka(dadoteka1);
    printBinarnaDadoteka(dadotekaIzlazna);
    return 0;
}