#include "liste.h"
#include "base.h"
#include <math.h>


bool isEmpty(FILE *file)
{
    long savedOffset = ftell(file);
    fseek(file, 0, SEEK_END);

    if (ftell(file) == 0)
    {
        return true;
    }

    fseek(file, savedOffset, SEEK_SET);
    return false;
}

/*******************************************************************************************************************/
// 1.
void formiranjePrazne(){

    FILE* datoteka;
    char naziv[MAX_CHAR];
    printf("\nUnesite naziv datoteke: \n");
    fflush(stdin);
    gets(naziv);

    datoteka = fopen(naziv,"wb");

    if (datoteka==NULL){
        printf("Datoteka <%s> nije uspesno otvorena\n",naziv);
        return;
    } else {
        printf("Datoteka <%s> je uspesno otvorena\n",naziv);
    }
    fclose(datoteka);
}

/*******************************************************************************************************************/

// 2.
void izborAktivne() {

    FILE* datoteka;
    char naziv[MAX_CHAR];

    printf("\nUnesite naziv datoteke koju zelite da proglasite aktivnom: \n");
    fflush(stdin);
    gets(naziv);
    strcpy(aktivna,naziv);

    datoteka = fopen(naziv,"rb+");

    if (datoteka==NULL){
        printf("\nDatoteka <%s> nije uspesno otvorena\n", naziv);
        return;
    }

    if (indSek != NULL)
        fclose(indSek);


    indSek = datoteka;
    strcpy(aktivna, naziv);
    printf("Datoteka '%s' je aktivna!\n", naziv);

    fclose(datoteka);


}

/*******************************************************************************************************************/

// 3.
void prikazAktivne(){
    if (strcmp(aktivna,"")==0){
        printf("\nNijedna datoteka nije aktivna!\n");
    }else
        printf("\nAktivna datoteka: <%s>\n", aktivna);
}

/*******************************************************************************************************************/

// 4.
void formiranjeSerijske() {
    FILE *fajl;
    unsigned long kljuc;
    Slog temp;
    Slog novi;

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

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

        novi.e_br = kljuc;
        fclose(fajl);


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

        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.datum, "%d.%d.%d. %d:%d", d, m, g, s, minut);

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

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

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

   // } while (odg != 'n' || odg != 'N');

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

    }
}

/*******************************************************************************************************************/

void citajSerijsku() {
    FILE *serijska;
    Slog temp;
    serijska = fopen("serijska", "rb");
    while (fread(&temp, sizeof(Slog), 1, serijska)){
        printf("\nE_BR: %ld\nSIFRA_ZAT: %s\nDATUM: %s\nOZNAKA_CELIJE: %s\nDUZINA_KAZNE: %d\n",temp.e_br, temp.sifra_zat, temp.datum, temp.oznaka_celije, temp.duzina_kazne);
    }
}

/*******************************************************************************************************************/

void citajSekvencijalnu(){
    FILE *sekv;
    Slog temp;
    sekv = fopen("sekvencijalna","rb");
    while (fread(&temp, sizeof(Slog), 1, sekv)){
        printf("\nE_BR: %ld\nSIFRA_ZAT: %s\nDATUM: %s\nOZNAKA_CELIJE: %s\nDUZINA_KAZNE: %d\n",temp.e_br, temp.sifra_zat, temp.datum, temp.oznaka_celije, temp.duzina_kazne);
    }
}

/*******************************************************************************************************************/

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

    int i = 0; //brojac broja slogova

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

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

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

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

    // Cleanup
    fclose(sekv);
    free(iteratorListe);
    obrisiListu(&glava);
    printf("\nFormiranje proslo uspjesno!\n");
}

/*******************************************************************************************************************/

void formiranjePrimarneZone(){
    Slog temp;
    Blok_primarne_zone blok;

    indSek = fopen(aktivna, "ab");

        if (isEmpty(indSek)) {
        printf("Datoteka je prazna!\n");
        return;
    }

    int i=0;

    blok.glava=NULL;

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

    while (fread(&temp, sizeof(Slog), 1, sekv)) {
           if (i == F_BL) {
                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(){
    int brojBlokova = 0;
    Blok temp;

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

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

    int visinaStabla = ceil(log2(brojBlokova)); // formula

    int brojCvorova = 0;

    int i;

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

    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];

// Ovo nemam pojma, pomago mi drug...
    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[F_BL-1].e_br;
                slog1.adresa_bloka = i;
            }
            else {
                slog2 = *((Slog_u_zoni_indexa*) malloc( sizeof(Slog_u_zoni_indexa)));
                slog2.kljuc = bls.slogovi[F_BL-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(aktivna, "ab");

    iteratorListe = glava;
    printf("\n*************NIVO%d******************", visinaStabla);
    while (iteratorListe != NULL){
        printf("\n*******************************");
         printf("\n Adresa %d\nKljuc %ld", iteratorListe->blok.slogovi[0].adresa_bloka, iteratorListe->blok.slogovi[0].kljuc);
         printf("\n Adresa %d\nKljuc %ld", iteratorListe->blok.slogovi[1].adresa_bloka, iteratorListe->blok.slogovi[1].kljuc);
        printf("\n**********************************\\/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;

        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;
                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(aktivna, "ab");

        while (iteratorListe != NULL) {
            printf("\n*******************************");
             printf("\n Adresa %d\nKljuc %ld", iteratorListe->blok.slogovi[0].adresa_bloka, iteratorListe->blok.slogovi[0].kljuc);
             printf("\n Adresa %d\nKljuc %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);
        }
        */
}

/*******************************************************************************************************************/

// 6.
void formiranjeIndexSekvencijalne() {

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

    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 (strcmp(aktivna,"") == 0){
        printf("\nNijedna datoteka nije aktivna!\n");
        return;
    }

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

    formiranjePrimarneZone();
    formiranjeZoneIndeksa();

    listaSlogovaPre *glava = NULL;
    listaSlogovaPre *iteratorListe;

    Slog_prekoracilac slog;
    slog.prekoracilac.e_br = 0;

    int j;
    for(j=0; j < MAX_PREKORACILACA; j++){
        dodajSlogPre(&glava, &slog);
    }
    Slog_prekoracilac slog2;
    iteratorListe=glava;

    indSek = fopen(aktivna, "ab");

    while (iteratorListe != NULL) {
        slog2=iteratorListe->slog;
        fwrite(&slog2,sizeof(Slog_prekoracilac), 1, indSek);
        iteratorListe = iteratorListe->next;
    }

    fclose(indSek);
    indSek = fopen(aktivna, "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(aktivna, "rb+");
    rewind(indSek);
    fwrite(&blokZaglavlja,sizeof(Zaglavlje), 1, indSek);
    fclose(indSek);

    indSek = fopen(aktivna, "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);
}

/*******************************************************************************************************************/

// 10.
void ispisCeleDatoteke(){
    if (strcmp(aktivna,"")==0){
        printf("\nNijedna datoteka nije aktivna!\n");
        return;
    }

    indSek = fopen(aktivna,"rb");

    if (isEmpty(indSek)) {
        printf("Datoteka je prazna!\n");
        return;
    }

    Zaglavlje zag;

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

    printf("\n********PRIMARNA ZONA*******\n");
    int i, 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("\nEvidencioni broj: %ld", tempSlog.e_br);
            printf("\nSifra zatvorenika: %s", tempSlog.sifra_zat);
            printf("\nDatum i vrijeme: %s", tempSlog.datum);
            printf("\nOznaka celije: %s", tempSlog.oznaka_celije);
            printf("\nDuzina kazne: %d", tempSlog.duzina_kazne);
            printf("\n******************************************\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("\nEvidencioni broj: %ld", tempSlogPrekoracilac.prekoracilac.e_br);
            printf("\nSifra zatvorenika: %s", tempSlogPrekoracilac.prekoracilac.sifra_zat);
            printf("\nDatum i vrijeme: %s", tempSlogPrekoracilac.prekoracilac.datum);
            printf("\nOznaka celije: %s", tempSlogPrekoracilac.prekoracilac.oznaka_celije);
            printf("\nDuzina kazne: %d", tempSlogPrekoracilac.prekoracilac.duzina_kazne);
            printf("\n******************************************\n");
        }
    }
    fclose(indSek);
}

/*******************************************************************************************************************/

// 7.
void upisSloga() {

    if (strcmp(aktivna, "") == 0){
        printf("\nNijedna datoteka nije aktivna");
        return;
    }

    indSek = fopen(aktivna,"rb");

    Zaglavlje zag;

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

    int i, j, k = 0;
    int nkljucevi = zag.br_blokova_pz * F_BL + 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\n** Unos 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 vec postoji!\n");
                kljuc = 0;
                break;
            }
        }
    }while (kljuc < 10000000 || kljuc > 99999999);

        novi.e_br = kljuc;

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

        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.datum, "%d.%d.%d. %d:%d", d, m, g, s, minut);

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

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

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

        indSek = fopen(aktivna,"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);
}