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

#define BUFFER_SIZE 100
#define FILE_HEADER_STRING "__info2_image_file_format__"

// TODO Implementieren Sie geeignete Hilfsfunktionen für das Lesen der Bildserie aus einer Datei

//Hilfsfunktion Header prüfen, beginnt die mit dem String?
static int checkHeader(FILE *file) {
    const char *erwartet = FILE_HEADER_STRING; //erwarteter String
    size_t len = strlen(erwartet); //länge, size_t ist Datentyp

    // Platz für genau len Bytes (ohne Nullterminator)
    unsigned char buf[BUFFER_SIZE]; //passenden Speicher vorbereiten
    if (len > BUFFER_SIZE) return 0;

    // Exakt die länge an Bytes lesen
    size_t r = fread(buf, 1, len, file);
    if (r != len) return 0;

    // Byteweiser Vergleich
    return memcmp(buf, erwartet, len) == 0; //Bitweiser vergleich, strcmp geht nicht
}

//Hilfsfkt. 2 Bytes als unsigned short lesen
static unsigned short read(FILE *file) {
    unsigned short value;
    if(fread(&value, sizeof(unsigned short), 1, file)!=1) //speichert 2 Bits in value, merkt sich, wo sie aufgehört hat zu lesen
      return 0;
    return value;
}


// TODO Vervollständigen Sie die Funktion readImages unter Benutzung Ihrer Hilfsfunktionen
GrayScaleImageSeries *readImages(const char *path)
{
 FILE *file = fopen(path, "rb"); //öffnet Datei im Binärmodus
    if (!file) return NULL;

   if (!checkHeader(file)) {  //beginnt datei mit dem string?
        fclose(file);
        return NULL;
    }

    unsigned short count  = read(file);  //lesen immer 2 Bits aus datei, string wurde oben schon gelesen, fread merkt sich
    unsigned short weite  = read(file);
    unsigned short höhe = read(file);

    if (count == 0 || weite == 0 || höhe == 0) { //ist was 0?
    fclose(file);
    return NULL;
}

    GrayScaleImageSeries *series = malloc(sizeof(GrayScaleImageSeries)); //reserviert Speicher
    if (!series) { fclose(file); return NULL; }

    series->count  = count; //auch(*series)count = count; speichert anzahl, kein speicher reservieren
    series->labels = malloc(count * sizeof(unsigned char)); //speicher bilder
    series->images = malloc(count * sizeof(GrayScaleImage)); //speicher für Bildstrukturen
    if (!series->labels || !series->images) { //geklappt?
        fclose(file);
        free(series->labels);
        free(series->images);
        free(series);
        return NULL;
    }
for (unsigned int i = 0; i < count; i++) { //liest alle bilder ein
        GrayScaleImage *bild = &series->images[i]; //Zeiger auf aktuelles Bild
        bild->width  = weite; //speichert Werte von diesem Bild
        bild->height = höhe;

    size_t pixels = (size_t)weite * (size_t)höhe;
    bild->buffer = malloc(pixels * sizeof(GrayScalePixelType)); //speicherwerte für Pixel


        if (!bild->buffer) { //geklappt?
            fclose(file);
            clearSeries(series);
            return NULL;
        }

        if (fread(bild->buffer, sizeof(GrayScalePixelType), weite * höhe, file) != weite * höhe) { // liest Pixelwerte aus Datei, speichert in Puffer
            fclose(file);
            clearSeries(series);
            return NULL;
        }

        if (fread(&series->labels[i], sizeof(unsigned char), 1, file) != 1) {
            fclose(file);
            clearSeries(series);
            return NULL;
        }
    }

    fclose(file);
    return series; //gibt Anzahl, Pixelwerte, labels zurück
}





// TODO Vervollständigen Sie die Funktion clearSeries, welche eine Bildserie vollständig aus dem Speicher freigibt
void clearSeries(GrayScaleImageSeries *series)
{
    if (!series) return;
    for (unsigned int i = 0; i < series->count; i++) { //ale Bilder leeren
        free(series->images[i].buffer);
    }
    free(series->images);
    free(series->labels);
    free(series);
}