#include "liste.h"

void dodajSlog(listaSlogova** glava, Slog* slog) {

    listaSlogova *prethodni, *trenutni;
    listaSlogova *temp = (listaSlogova*) malloc(sizeof(listaSlogova));
    memcpy(&temp->slog, slog, sizeof(Slog));

    if ((*glava) == NULL || (slog->ecidencioni_broj < (*glava)->slog.ecidencioni_broj)) {
        temp->next = *glava;
        *glava = temp;
    }
    else
    {
        prethodni = *glava;
        trenutni = (*glava)->next;

        while (1) {
            if ((trenutni == NULL) || (trenutni->slog.ecidencioni_broj > slog->ecidencioni_broj)) {
                prethodni->next = temp;
                temp->next = trenutni;
                break;
            }
            else {
                prethodni = trenutni;
                trenutni = trenutni->next;
            }
        }
    }
}

void obrisiListu(listaSlogova** glava) {

    listaSlogova* temp = *glava;
    listaSlogova* prosli;

    while (temp) {
        prosli = temp;
        temp = temp->next;
        free(prosli);
    }

    *glava = NULL;
}

void dodajList(listaListova** glava, Blok_u_zoni_indexa* slog) {

    listaListova *prethodni, *trenutni;
    listaListova *temp = (listaListova*) malloc(sizeof(listaListova));
    memcpy(&temp->blok, slog, sizeof(Blok_u_zoni_indexa));

    if ((*glava) == NULL) {
        temp->next = *glava;
        *glava = temp;
    }
    else
    {
        prethodni = *glava;
        trenutni = (*glava)->next;

        while (1) {
            if ((trenutni == NULL) ) {
                prethodni->next = temp;
                temp->next = trenutni;
                break;
            }
            else {
                prethodni = trenutni;
                trenutni = trenutni->next;
            }
        }
    }
}

void obrisiListuListova(listaListova** glava) {

    listaListova* temp = *glava;
    listaListova* prosli;

    while (temp) {
        prosli = temp;
        temp = temp->next;
        free(prosli);
    }

    *glava = NULL;
}

void dodajSlogPre(listaSlogovaPre** glava, Slog_prekoracilac* slog) {

    listaSlogovaPre *prethodni, *trenutni;
    listaSlogovaPre *temp = (listaSlogovaPre*) malloc(sizeof(listaSlogovaPre));
    memcpy(&temp->slog, slog, sizeof(Slog));

    if ((*glava) == NULL ) {
        temp->next = *glava;
        *glava = temp;
    }
    else
    {
        prethodni = *glava;
        trenutni = (*glava)->next;

        while (1) {
            if ((trenutni == NULL) ) {
                prethodni->next = temp;
                temp->next = trenutni;
                break;
            }
            else {
                prethodni = trenutni;
                trenutni = trenutni->next;
            }
        }
    }
}

void obrisiListuPre(listaSlogovaPre** glava) {

    listaSlogovaPre* temp = *glava;
    listaSlogovaPre* prosli;

    while (temp) {
        prosli = temp;
        temp = temp->next;
        free(prosli);
    }

    *glava = NULL;
}

void dodajBlok(ListoviStabla** glava, Blok_u_zoni_indexa* blok) {

    if((*glava) == NULL){
        *glava = (ListoviStabla*) malloc(sizeof(ListoviStabla));
        memcpy(&(*glava)->blokZI, blok, sizeof(Blok_u_zoni_indexa));
        (*glava)->next = NULL;
    }
    else{
        ListoviStabla *temp = (ListoviStabla*) malloc(sizeof(ListoviStabla));
        memcpy(&temp->blokZI, blok, sizeof(Blok_u_zoni_indexa));
        temp->next = NULL;
        ListoviStabla *pom = *glava;
        while(pom->next != NULL)
            pom = pom->next;
        pom->next = temp;
    }
}

void obrisiListuST(ListoviStabla** glava) {

    ListoviStabla* temp = *glava;
    ListoviStabla* prosli;

    while (temp) {
        prosli = temp;
        temp = temp->next;
        free(prosli);
    }

    *glava = NULL;
}

#include "zatvor.h"
#include "liste.h"

void clb() {
    fflush(stdin);
}

void cls() {
    system("cls");
}
/*
//-------------------------------------------------------------------------------------------------

int bucketAddress(char *key) {
    int m = BLOCK_FACTOR;
    int p = MAX_LEN_ENTRY;    // broj karaktera evidencionog broja
    int sum = 0, i = 0, addr = 0;

    for (i = 0; i < p; i++) {
        // skuplja karatkere i od toga pravi sumu (tj broj koji je unijet)
        sum += (key[i] - 48) * pow(10, (-i + p-1));
    }
    //  printf("\n\n%d\n\n", suma); // samo provjera unijete vrijednosti evidencionog broja

    addr = 1 + sum % m;

    return addr;
}

//-------------------------------------------------------------------------------------------------

void open_active_file(active_file *dat, char *name) {
    if ((dat->dat = fopen(name, "rb+")) == NULL) {
        printf("Datoteka '%s' ne postoji.\n", name);
        return;
    }

    strcpy(dat->file_name, name);
    printf("Datoteka '%s' je aktivna!\n", name);
}

//-------------------------------------------------------------------------------------------------

void close_active_file(active_file *dat) {
    if (dat->dat == NULL)
    return;

    fclose(dat->dat);
    printf("Aktivna datoteka %s je uspjesno zatvorena!\n", dat->dat);
}

//-------------------------------------------------------------------------------------------------


void show_active_fName(active_file *dat) {
    if ((dat->dat) == NULL ) {
            printf("\nNema aktivnih datoteka.\n");
            return;
    }

    printf("Aktivna je datoteka '%s'.\n", dat->file_name);
}

//-------------------------------------------------------------------------------------------------

void mk_new_file(active_file *dat, char *name) {
    if((dat->dat = fopen(name, "wb")) == NULL) {
        fprintf(stderr, "\nDoslo je do greske prilikom otvaranja datoteke!\n");
        return;
    }
    strcpy(dat->file_name, name);

    Zatvor z = {"", "", "", "", ""}; // Inicijalizacija za elemente
    Bucket b;
    // Faktor baketiranja pa idemo do 5 ???
    b.bucket_count[0] = z;
    b.bucket_count[1] = z;
    b.bucket_count[2] = z;
    b.bucket_count[3] = z;
    b.bucket_count[4] = z;
    b.overflow = false;

    if (fwrite(&b, sizeof(Bucket), 1, dat->dat) != 1) {
        fprintf(stderr, "\nGreska prilikom zauzimanja memorije za datoteku!\n");
        return;
    }
    printf("\nDatoteka %s uspjesno kreirana!\n", dat->dat);

    int bra = bucketAddress(z.k_duration);
    printf("\nDEBUG ADDR_B: %d\n", bra);

    fclose(dat->dat);
    open_active_file(dat, name);

}

//-------------------------------------------------------------------------------------------------
*/

// 1.
void makeFile(active_file *dat, char *name) {
    if((dat->dat = fopen(name, "wb")) == NULL) {
        printf("\nDoslo je do greske prilikom kreiranja datoteke!\n");
        return;
    }
    else {
        printf("Datoteka %s je uspjesno kreirana!\n", name);
    }

    fclose(dat->dat);
}

// 2.
void izborAktivne(active_file *dat, char *name) {
    if ((dat->dat = fopen(name, "rb+")) == NULL) {
        printf("Datoteka '%s' ne postoji.\n", name);
        return;
    }

    if (indSek != NULL)
        fclose(indSek);
    indSek = dat->dat;

    strcpy(dat->file_name, name);
    printf("Datoteka '%s' je aktivna!\n", name);
}

// 3.
void prikazAktivne(active_file *dat) {
    if ((dat->dat) == NULL ) {
        printf("\nNema aktivnih datoteka.\n");
        return;
    }

    printf("Aktivna je datoteka '%s'.\n", dat->file_name);
}

// 4.
void formiranjeSerijske(active_file *dat, char *name) {
    unsigned long kljuc;
    Slog temp;
    Slog novi;

    int i;
    for (i = 0; i < BLOCK_FACTOR; i++) {
        dat->dat = fopen("serijska","rb");
        printf("\n %d. slog", i+1);

        do{
            printf("\nEvidencioni broj (10000000-99999999): ");
            fflush(stdin);
            scanf("%ld", &kljuc);
            while (fread(&temp, sizeof(Slog), 1, dat->dat)){
                if (temp.e_br == kljuc) {
                    printf("\nEvidencioni broj postoji!\n");
                    kljuc = 0;
                    break;
                }
            }
        } while (kljuc < 10000000 || kljuc > 99999999);

        novi.e_br = kljuc;

        fclose(dat->dat);

        printf("\nUnesite sifru zatvorenika (max. 7 znakova!):\t");
        fflush(stdin);
        gets(novi.z_id);

        int d, m, g, s, minut; // Datum!
        printf("\nUnos datuma i vremena:\n");
        do {
            printf("\nUnesite godinu:\t");
            fflush(stdin);
            scanf("%d", &g);
        } while (g < 1900 || g > 2100);

        do{
            printf("\nUnesite mjesec:\t");
            fflush(stdin);
            scanf("%d", &m);
        } while (m<1 || m>12);

        // Kontrole:
        switch (m) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                do {
                    printf("\nUnesite dan:\t");
                    fflush(stdin);
                    scanf("%d", &d);
                } while (d < 1 || d > 31);
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                do {
                    printf("\nUnesi dan:\t");
                    fflush(stdin);
                    scanf("%d", &d);
                } while (d < 1 || d > 31);
                break;
            case 2:
                if (g % 4 == 0) {
                    do {
                        printf("\nUnesite dan:\t");
                        fflush(stdin);
                        scanf("%d", &d);
                    } while (d < 1 || d > 29);
                }
                else {
                    do {
                        printf("\nUnesite dan:\t");
                        fflush(stdin);
                        scanf("%d", &d);
                    } while (d < 1 || d > 28);
                }
                break;


        }
        do {
            printf("\nUnesite sat:\t");
            fflush(stdin);
            scanf("%d", &s);
        } while (s < 0 || s > 23);

        do {
            printf("\nUnesite minut:\t");
            fflush(stdin);
            scanf("%d", &minut);
        } while (minut < 0 || minut > 59);

         sprintf(novi.dt_arrival, "%d.%d.%d. %d:%d", d, m, g, s, minut);

        do {
            printf("\nUnesite oznaku celije zatvorenika (Tacno 5 karaktera):\t");
            fflush(stdin);
            gets(novi.id_cell);

        } while (strlen(novi.id_cell) != 5);

        do {
            printf("\nUnesite duzinu kazne (max. 480 mjeseci!): ");
            fflush(stdin);
            scanf("%d", &novi.k_duration);
        }while (novi.k_duration < 1 || novi.k_duration > 480);

        dat->dat = fopen("serijska", "ab+");
        fwrite(&novi, sizeof(Slog), 1, dat->dat);
        fclose(dat->dat);

    }
}

void citajSerijsku() {
    active_file *dat;
 //   Blok blok;
    Slog temp;
    dat->dat = fopen("serijska", "rb");
    while (fread(&temp, sizeof(Slog), 1, dat->dat)){
        printf("\nE_BR: %ld\nS_Z: %s\nDat: %s\nC_ID: %s\nD_KZ: %d\n",temp.e_br,temp.z_id,temp.dt_arrival,temp.id_cell,temp.k_duration);
    }
}

void citajSekvencijalnu(){
   active_file *dat;
 //   Blok blok;
    Slog temp;
    dat->dat = fopen("sekvencijalna", "rb");
    while (fread(&temp, sizeof(Slog), 1, dat->dat)){
         printf("\nE_BR: %ld\nS_Z: %s\nDat: %s\nC_ID: %s\nD_KZ: %d\n",temp.e_br,temp.z_id,temp.dt_arrival,temp.id_cell,temp.k_duration);
    }
}

// 5.
void formirajSekvencijalnu() {
    FILE *ser;
    FILE *sekv;
    Slog temp;
    Blok blok;
    listaSlogova *glava = NULL;
    listaSlogova *iteratorListe;
    ser = fopen("serijska", "rb");

    int i = 0; //brojac broja slogova

    //citamo iz serijske i upisujemo na odg. mjesto u listu
    while (fread(&temp, sizeof(Slog), 1, ser)) {
        dodajSlog(&glava, &temp );
    }
    fclose(ser);

    //citamo iz liste i pisemo u sekvencijalnu
    sekv = fopen("sekvencijalna", "wb");
    iteratorListe = glava;

    while(iteratorListe != NULL) {
        blok.slogovi[i] = iteratorListe->slog;
        i++;
        if (i == BLOCK_FACTOR) {
            fwrite(&blok, sizeof(Blok), 1, sekv);
            i = 0;
        }
        iteratorListe = iteratorListe->next;
    }

  //  blok.slogovi[0].ecidencioni_broj = -1; //upisi preostale i oznaku kraja podataka
 //   fwrite(&blok, sizeof(Blok), 1, sekv);

    //zatvori fajl i oslobodi liste
    fclose(sekv);
    free(iteratorListe);
    obrisiListu(&glava);
}

void formirajPrimarnuZonu(active_file *dat){
  //  FILE *sekv;
  //  FILE *indSek;
    Slog temp;
    Blok_primarne_zone blok;

    indSek = fopen(dat->dat, "ab");

    int i = 0;

    blok.glava = NULL;

    sekv = fopen("sekvencijalna", "rb");

    while (fread(&temp, sizeof(Slog), 1, sekv)){

           if (i==(BLOCK_FACTOR)) {
                fwrite(&blok, sizeof(Blok_primarne_zone), 1, indSek);
                i = 0;
           }
            blok.slogovi[i] = temp;
            i++;
    }
    fwrite(&blok,sizeof(Blok_primarne_zone), 1, indSek);
    fclose(sekv);
    fclose(indSek);
}

void formiranjeZoneIndeksa(active_file *dat){

   // FILE *sekv;
    int brojBlokova = 0;
    Blok temp;

    sekv = fopen("sekvencijalna", "rb");

    while (fread(&temp, sizeof(Blok), 1, sekv)){
        brojBlokova++;
    }
    fclose(sekv);

    int visinaStabla = ceil(log2(brojBlokova)); // Po formuli

    int brojCvorova = 0;

    int i;

    for(i=0; i < visinaStabla; i++) {
        brojCvorova += ceil((float)brojBlokova/pow(RST,(visinaStabla-i))); // Po formuli!
    }


    int brojListova = ceil((float)brojBlokova/(float)RST);

    printf("\nbroj blokova %d", brojBlokova);
    printf("\nvisina stabla %d", visinaStabla);
    printf("\nbroj cvorova %d", brojCvorova);
    printf("\nbroj listova %d", brojListova);

    listaListova *glava = NULL;
    listaListova *iteratorListe;

    sekv =fopen("sekvencijalna", "rb");
    Blok bls;
    Slog_u_zoni_indexa slog1,slog2;
    Blok_u_zoni_indexa kBlo;
    ElementNiza niz[brojCvorova];

    int brojacElemenata=0;
    for(i=0; i<brojBlokova; i++) {
            fread(&bls, sizeof(Blok), 1, sekv);
            if (i % 2 == 0) {
                slog1 = *((Slog_u_zoni_indexa*) malloc( sizeof(Slog_u_zoni_indexa)));
                slog1.kljuc = bls.slogovi[BLOCK_FACTOR-1].e_br;
                slog1.adresa_bloka=i;
            }
            else{
                slog2 = *((Slog_u_zoni_indexa*) malloc( sizeof(Slog_u_zoni_indexa)));
                slog2.kljuc = bls.slogovi[BLOCK_FACTOR-1].e_br;
                slog2.adresa_bloka = i;
            }

            if (i % 2 == 1) {
                kBlo.slogovi[0] = slog1;
                kBlo.slogovi[1] = slog2;
                dodajList(&glava, &kBlo);
                niz[brojacElemenata].blok = kBlo;
                niz[brojacElemenata].kljuc = brojacElemenata;
                brojacElemenata++;
            }
    }

    if (brojBlokova % 2 == 1) {
        kBlo.slogovi[0] = slog1;
        slog2 = *((Slog_u_zoni_indexa*) malloc( sizeof(Slog_u_zoni_indexa)));
        slog2.adresa_bloka = -1;
        slog2.kljuc = 0;
        kBlo.slogovi[1] = slog2;
        dodajList(&glava, &kBlo);
        niz[brojacElemenata].blok = kBlo;
        niz[brojacElemenata].kljuc = brojacElemenata;
        brojacElemenata++;
    }
    fclose(sekv);

    indSek = fopen(dat->dat, "ab");

    iteratorListe=glava;
    printf("\n*************NIVO %d******************", visinaStabla);
    while (iteratorListe != NULL){
        printf("\n*******************************");
         printf("\n adresa %d \n kljuc %ld",iteratorListe->blok.slogovi[0].adresa_bloka, iteratorListe->blok.slogovi[0].kljuc);
         printf("\n adresa %d \n kljuc %ld",iteratorListe->blok.slogovi[1].adresa_bloka, iteratorListe->blok.slogovi[1].kljuc);
        printf("\n*******************************");
        Blok_u_zoni_indexa blok = iteratorListe->blok;
        fwrite(&blok, sizeof(Blok_u_zoni_indexa), 1, indSek);

         iteratorListe = iteratorListe->next;
    }
    fclose(indSek);

    int k;
    for (k=0; k < visinaStabla-1; k++) {
        listaListova *glava2 = NULL;
   // listaListova *iteratorListe2;

        iteratorListe=glava;
        Blok_u_zoni_indexa kBlo2;
        int brB = 0;

        while (iteratorListe != NULL){
            if (brB == 2){
                dodajList(&glava2, &kBlo2);
                niz[brojacElemenata].blok = kBlo;
                niz[brojacElemenata].kljuc = brojacElemenata;
                brojacElemenata++;
                brB = 0;
                //iteratorListe = iteratorListe->next;
                continue;
            }

            if (iteratorListe->blok.slogovi[1].kljuc != 0)
                kBlo2.slogovi[brB]=iteratorListe->blok.slogovi[1];
            else
                kBlo2.slogovi[brB]=iteratorListe->blok.slogovi[0];


             iteratorListe = iteratorListe->next;
             brB++;
        }

        if (brB == 1) {
            kBlo2.slogovi[1].adresa_bloka = -1;
            kBlo2.slogovi[1].kljuc = 0;
        }

         dodajList(&glava2,&kBlo2);
         niz[brojacElemenata].blok=kBlo;
         niz[brojacElemenata].kljuc=brojacElemenata;
         brojacElemenata++;



         printf("\n************NIVO %d*******************", visinaStabla-k-1);
        iteratorListe=glava2;
        indSek=fopen(dat->dat, "ab");
        while (iteratorListe != NULL){
            printf("\n*******************************");
             printf("\n adresa %d \n kljuc %ld",iteratorListe->blok.slogovi[0].adresa_bloka,iteratorListe->blok.slogovi[0].kljuc);
             printf("\n adresa %d \n kljuc %ld",iteratorListe->blok.slogovi[1].adresa_bloka,iteratorListe->blok.slogovi[1].kljuc);
            printf("\n*******************************");
            Blok_u_zoni_indexa blok2=iteratorListe->blok;
        fwrite(&blok2,sizeof(Blok_u_zoni_indexa),1,indSek);
             iteratorListe = iteratorListe->next;
        }
        fclose(indSek);
        brojCvorova = (brojCvorova % 2) + (brojCvorova / 2);
        glava=glava2;
        }

      //  printf("\nDEBUG\n");

       /* int nesto=0;
        for(nesto;nesto<brojacElemenata;nesto++){
            printf("\nkljuc %d",niz[nesto].kljuc);
            printf("\nslog1 adresa %d  ev broj %ld",niz[nesto].blok.slogovi[0].adresa_bloka,niz[nesto].blok.slogovi[0].kljuc);
            printf("\nslog2 adresa %d  ev broj %ld",niz[nesto].blok.slogovi[1].adresa_bloka,niz[nesto].blok.slogovi[1].kljuc);
        }
*/
   //     StabloTrazenja *stablo;
    //    formirajStablo(niz,brojacElemenata,&stablo);

       // prikaziStablo(stablo);
}

void formiranjeIndexSekvencijalne(active_file *dat, char *name) {
    int brojBlokova = 0;
    Blok temp;

    sekv = fopen("sekvencijalna","rb");

    while (fread(&temp, sizeof(Blok), 1, sekv)) {
        brojBlokova++;
    }
    fclose(sekv);

    int visinaStabla = ceil(log2(brojBlokova));

    int brojCvorova=0;

    int i;

    for(i=0;i<visinaStabla;i++){
        brojCvorova+=ceil((float)brojBlokova/pow(RST,(visinaStabla-i)));
    }

    Zaglavlje blokZaglavlja;
    blokZaglavlja.br_blokova_pz=brojBlokova;
    blokZaglavlja.br_blokova_zi=brojCvorova;
    blokZaglavlja.adresa_pocetka_zi=-1;


 if ((dat->dat = fopen(name, "rb+")) == NULL) {
        printf("Datoteka '%s' ne postoji.\n", name);
        return;
    }

    indSek = fopen(dat->dat, "wb");
    fwrite(&blokZaglavlja, sizeof(Zaglavlje), 1, indSek);
    fclose(indSek);

    formiranjePrimarneZone();
    formiranjeZoneIndeksa();

    listaSlogovaPre *glava=NULL;
    listaSlogovaPre *iteratorListe;

    Slog_prekoracilac slog;
    slog.prekoracilac.ecidencioni_broj=0;

    int j;
    for(j=0;j<MAX_PREKORACILACA;j++){
        dodajSlogPre(&glava,&slog);
    }
    Slog_prekoracilac slog2;
    iteratorListe=glava;
    indSek=fopen(dat->dat,"ab");
    while (iteratorListe != NULL){
        slog2=iteratorListe->slog;
        fwrite(&slog2,sizeof(Slog_prekoracilac),1,indSek);
        iteratorListe = iteratorListe->next;
    }
    fclose(indSek);
    indSek=fopen(dat->dat,"rb");
    rewind(indSek);
    fseek(indSek,sizeof(Zaglavlje),SEEK_SET);
    fseek(indSek,brojBlokova*sizeof(Blok_primarne_zone),SEEK_CUR);
    fseek(indSek,brojCvorova*sizeof(Blok_u_zoni_indexa),SEEK_CUR);
    int pocetakZonePrekoracenja = ftell(indSek);
    fclose(indSek);

    blokZaglavlja.adresa_pocetka_zi=pocetakZonePrekoracenja;

    indSek=fopen(dat->dat,"rb+");
    rewind(indSek);
    fwrite(&blokZaglavlja,sizeof(Zaglavlje),1,indSek);
    fclose(indSek);

    indSek=fopen(dat->dar,"rb+");
    fseek(indSek,pocetakZonePrekoracenja,SEEK_SET);
    int korak=sizeof(Slog_prekoracilac);
    Slog_prekoracilac sp;
    for(i=0;i<MAX_PREKORACILACA;i++){
        fread(&sp,sizeof(Slog_prekoracilac),1,indSek);
        sp.sledeci=ftell(indSek)+korak;
    }

    fclose(indSek);
}

void ispisCeleDatoteke(active_file *dat, char *name){

 if ((dat->dat = fopen(name, "rb+")) == NULL) {
        printf("Datoteka '%s' ne postoji.\n", name);
        return;
    }

    indSek = fopen(dat->dat,"rb");
    Zaglavlje zag;


    fread(&zag,sizeof(Zaglavlje),1,indSek);


    printf("\n********PRIMARNA ZONA*******\n");
    int i;
    int j;
    Blok_primarne_zone temp;
    for(i=0;i<zag.br_blokova_pz;i++){
        fread(&temp,sizeof(Blok_primarne_zone),1,indSek);
        for(j=0;j<F_BL;j++){
            Slog tempSlog;
            tempSlog=temp.slogovi[j];
            int adresaBloka = ftell(indSek);
            int rbSloga=j;
            printf("\nAdresa bloka: %d",adresaBloka);
            printf("\nRedni broj sloga u bloku: %d",rbSloga);
            printf("\n\tEvidencioni broj: %ld",tempSlog.e_br);
            printf("\n\tRegistarska oznaka vozila: %s",tempSlog.z_id);
            printf("\n\tDatum i vreme: %s",tempSlog.dt_arrival);
            printf("\n\tKategorija vozila: %s",tempSlog.id_cell);
            printf("\n\tBroj putnika: %d",tempSlog.k_duration);
            printf("\n******************************************");
        }
    }

    rewind(indSek);
    fseek(indSek,zag.adresa_pocetka_zi,SEEK_SET);
    printf("\n\n********ZONA PREKORACENJA*******\n");
    Slog_prekoracilac tempSlogPrekoracilac;
    for(i=0;i<MAX_PREKORACILACA;i++){
        fread(&tempSlogPrekoracilac,sizeof(Slog_prekoracilac),1,indSek);
        if (tempSlogPrekoracilac.prekoracilac.e_br>0){
            printf("\n\tEvidencioni broj: %ld",tempSlogPrekoracilac.prekoracilac.e_br);
            printf("\n\tRegistarska oznaka vozila: %s",tempSlogPrekoracilac.prekoracilac.z_id);
            printf("\n\tDatum i vreme: %s",tempSlogPrekoracilac.prekoracilac.dt_arrival);
            printf("\n\tKategorija vozila: %s",tempSlogPrekoracilac.prekoracilac.id_cell);
            printf("\n\tBroj putnika: %d",tempSlogPrekoracilac.prekoracilac.k_duration);
            printf("\n******************************************");
        }
    }
    fclose(indSek);
}

void upisSloga(active_file *dat, char *name){

 if ((dat->dat = fopen(name, "rb+")) == NULL) {
        printf("Datoteka '%s' ne postoji.\n", name);
        return;
    }

    indSek = fopen(dat->dat,"rb");

    Zaglavlje zag;

    fread(&zag,sizeof(Zaglavlje),1,indSek);

    int i;
    int j;
    int k=0;
    int nkljucevi=zag.br_blokova_pz*BLOCK_FACTOR+MAX_PREKORACILACA;
    unsigned long kljucevi[nkljucevi];

    Blok_primarne_zone tempBlok;
    Slog tempSlog;

    for(i=0;i<zag.br_blokova_pz;i++){
        fread(&tempBlok,sizeof(Blok_primarne_zone),1,indSek);
        for(j=0;j<F_BL;j++){
            tempSlog=tempBlok.slogovi[i];
            kljucevi[k]=tempSlog.e_br;
            k++;
        }
    }

    fseek(indSek,zag.adresa_pocetka_zi,SEEK_SET);

    Slog_prekoracilac tempSlogPre;

    for (i=0;i<MAX_PREKORACILACA;i++){
        fread(&tempSlogPre,sizeof(Slog_prekoracilac),1,indSek);
        kljucevi[k]=tempSlogPre.prekoracilac.e_br;
        k++;
    }

    fclose(indSek);

    unsigned long kljuc;
    Slog novi;

    printf("\n\nUnos novog sloga: ");

    do{
            printf("\nEvidencioni broj (10000000-99999999): ");
            fflush(stdin);
            scanf("%ld",&kljuc);
            for (i=0;i<nkljucevi;i++){
                if (kljucevi[i]==kljuc){
                    printf("\nEvidencioni broj postoji");
                    kljuc=0;
                    break;
                }
            }
        }while (kljuc<10000000 || kljuc>99999999);

        novi.e_br=kljuc;

       printf("\nUnesite sifru zatvorenika (max. 7 znakova!):\t");
        fflush(stdin);
        gets(novi.z_id);

        int d, m, g, s, minut; // Datum!
        printf("\nUnos datuma i vremena:\n");
        do {
            printf("\nUnesite godinu:\t");
            fflush(stdin);
            scanf("%d", &g);
        } while (g < 1900 || g > 2100);

        do{
            printf("\nUnesite mjesec:\t");
            fflush(stdin);
            scanf("%d", &m);
        } while (m<1 || m>12);

        // Kontrole:
        switch (m) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                do {
                    printf("\nUnesite dan:\t");
                    fflush(stdin);
                    scanf("%d", &d);
                } while (d < 1 || d > 31);
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                do {
                    printf("\nUnesi dan:\t");
                    fflush(stdin);
                    scanf("%d", &d);
                } while (d < 1 || d > 31);
                break;
            case 2:
                if (g % 4 == 0) {
                    do {
                        printf("\nUnesite dan:\t");
                        fflush(stdin);
                        scanf("%d", &d);
                    } while (d < 1 || d > 29);
                }
                else {
                    do {
                        printf("\nUnesite dan:\t");
                        fflush(stdin);
                        scanf("%d", &d);
                    } while (d < 1 || d > 28);
                }
                break;


        }
        do {
            printf("\nUnesite sat:\t");
            fflush(stdin);
            scanf("%d", &s);
        } while (s < 0 || s > 23);

        do {
            printf("\nUnesite minut:\t");
            fflush(stdin);
            scanf("%d", &minut);
        } while (minut < 0 || minut > 59);

         sprintf(novi.dt_arrival, "%d.%d.%d. %d:%d", d, m, g, s, minut);

        do {
            printf("\nUnesite oznaku celije zatvorenika (Tacno 5 karaktera):\t");
            fflush(stdin);
            gets(novi.id_cell);

        } while (strlen(novi.id_cell) != 5);

        do {
            printf("\nUnesite duzinu kazne (max. 480 mjeseci!): ");
            fflush(stdin);
            scanf("%d", &novi.k_duration);
        }while (novi.k_duration < 1 || novi.k_duration > 480);

        indSek=fopen(dat->dat,"rb+");
        fseek(indSek,zag.adresa_pocetka_zi,SEEK_SET);


        for (i=0;i<MAX_PREKORACILACA;i++){
            fread(&tempSlogPre,sizeof(Slog_prekoracilac),1,indSek);
            if(tempSlogPre.prekoracilac.e_br==0){
                fseek(indSek,zag.adresa_pocetka_zi+i*sizeof(Slog_prekoracilac),SEEK_SET);
                fwrite(&novi,sizeof(Slog),1,indSek);
                break;
            }
        }
        fclose(indSek);

}