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


static void prepareImageFile(const char *path, unsigned short int width, unsigned short int height, unsigned int short numberOfImages, unsigned char label)
{
    FILE *file = fopen(path, "wb");

    if(file != NULL)
    {
        const char *fileTag = "__info2_image_file_format__";
        GrayScalePixelType *zeroBuffer = (GrayScalePixelType *)calloc(numberOfImages * width * height, sizeof(GrayScalePixelType));

        if(zeroBuffer != NULL)
        {
            fwrite(fileTag, sizeof(fileTag[0]), strlen(fileTag), file);
            fwrite(&numberOfImages, sizeof(numberOfImages), 1, file);
            fwrite(&width, sizeof(width), 1, file);
            fwrite(&height, sizeof(height), 1, file);

            for(int i = 0; i < numberOfImages; i++)
            {
                fwrite(zeroBuffer, sizeof(GrayScalePixelType), width * height, file);
                fwrite(&label, sizeof(unsigned char), 1, file);
            }

            free(zeroBuffer);
        }

        fclose(file);
    }
}


void test_readImagesReturnsCorrectNumberOfImages(void)
{
    GrayScaleImageSeries *series = NULL;
    const unsigned short expectedNumberOfImages = 2;
    const char *path = "testFile.info2";
    prepareImageFile(path, 8, 8, expectedNumberOfImages, 1);
    series = readImages(path);
    TEST_ASSERT_NOT_NULL(series);
    TEST_ASSERT_EQUAL_UINT16(expectedNumberOfImages, series->count);
    clearSeries(series);
    remove(path);
}

void test_readImagesReturnsCorrectImageWidth(void)
{
    GrayScaleImageSeries *series = NULL;
    const unsigned short expectedWidth = 10;
    const char *path = "testFile.info2";
    // prepareImageFile(path, width, height, numberOfImages, label)
    prepareImageFile(path, expectedWidth, 8, 2, 1);
    series = readImages(path);
    TEST_ASSERT_NOT_NULL(series);
    TEST_ASSERT_NOT_NULL(series->images);
    TEST_ASSERT_EQUAL_UINT16(2, series->count);
    TEST_ASSERT_EQUAL_UINT16(expectedWidth, series->images[0].width);
    TEST_ASSERT_EQUAL_UINT16(expectedWidth, series->images[1].width);
    clearSeries(series);
    remove(path);
}

void test_readImagesReturnsCorrectImageHeight(void)
{
    GrayScaleImageSeries *series = NULL;
    const unsigned short expectedHeight = 10;
    const char *path = "testFile.info2";
    // prepareImageFile(path, width, height, numberOfImages, label)
    prepareImageFile(path, 8, expectedHeight, 2, 1);
    series = readImages(path);
    TEST_ASSERT_NOT_NULL(series);
    TEST_ASSERT_NOT_NULL(series->images);
    TEST_ASSERT_EQUAL_UINT16(2, series->count);
    TEST_ASSERT_EQUAL_UINT16(expectedHeight, series->images[0].height);
    TEST_ASSERT_EQUAL_UINT16(expectedHeight, series->images[1].height);
    clearSeries(series);
    remove(path);
}

void test_readImagesReturnsCorrectLabels(void)
{
    const unsigned char expectedLabel = 15;

    GrayScaleImageSeries *series = NULL;
    const char *path = "testFile.info2";
    prepareImageFile(path, 8, 8, 2, expectedLabel);
    series = readImages(path);
    TEST_ASSERT_NOT_NULL(series);
    TEST_ASSERT_NOT_NULL(series->labels);
    TEST_ASSERT_EQUAL_UINT16(2, series->count);
    for (int i = 0; i < 2; i++) {
        TEST_ASSERT_EQUAL_UINT8(expectedLabel, series->labels[i]);
    }
    clearSeries(series);
    remove(path);
}

void test_readImagesReturnsNullOnNotExistingPath(void)
{
    const char *path = "testFile.txt";
    remove(path);
    TEST_ASSERT_NULL(readImages(path));
}

void test_readImagesFailsOnWrongFileTag(void)
{
    const char *path = "testFile.info2";
    FILE *file = fopen(path, "w");
    if(file != NULL)
    {
        fprintf(file, "some_tag                  ");
        fclose(file);
        TEST_ASSERT_NULL(readImages(path));
    }
    remove(path);
}

// =====================================================
// Tests für Hilfsfunktion imageInput.c
// =====================================================

void test_openFileAndReadHeaderFailsOnZeroImageCount(void)
{
    // Test: Datei mit count=0 sollte fehlschlagen
    const char *path = "testZeroCount.info2";
    FILE *file = fopen(path, "wb");
    if (file != NULL) {
        const char *fileTag = "__info2_image_file_format__";
        unsigned short zero_count = 0; 
        unsigned short width = 28;
        unsigned short height = 28;
        
        fwrite(fileTag, sizeof(fileTag[0]), strlen(fileTag), file);
        fwrite(&zero_count, sizeof(unsigned short), 1, file);
        fwrite(&height, sizeof(unsigned short), 1, file);
        fwrite(&width, sizeof(unsigned short), 1, file);
        fclose(file);
    }
    
    // readImages sollte NULL zurückgeben bei count=0
    TEST_ASSERT_NULL(readImages(path));
    remove(path);
}

void test_openFileAndReadHeaderFailsOnZeroWidth(void)
{
    // Test: Datei mit width=0 sollte fehlschlagen
    const char *path = "testZeroWidth.info2";
    FILE *file = fopen(path, "wb");
    if (file != NULL) {
        const char *fileTag = "__info2_image_file_format__";
        unsigned short count = 5;
        unsigned short width = 0;    
        unsigned short height = 28;
        
        fwrite(fileTag, sizeof(fileTag[0]), strlen(fileTag), file);
        fwrite(&count, sizeof(unsigned short), 1, file);
        fwrite(&height, sizeof(unsigned short), 1, file);
        fwrite(&width, sizeof(unsigned short), 1, file);
        fclose(file);
    }
    
    TEST_ASSERT_NULL(readImages(path));
    remove(path);
}

void test_openFileAndReadHeaderFailsOnZeroHeight(void)
{
    // Test: Datei mit height=0 sollte fehlschlagen
    const char *path = "testZeroHeight.info2";
    FILE *file = fopen(path, "wb");
    if (file != NULL) {
        const char *fileTag = "__info2_image_file_format__";
        unsigned short count = 5;
        unsigned short width = 28;
        unsigned short height = 0;   
        
        fwrite(fileTag, sizeof(fileTag[0]), strlen(fileTag), file);
        fwrite(&count, sizeof(unsigned short), 1, file);
        fwrite(&height, sizeof(unsigned short), 1, file);
        fwrite(&width, sizeof(unsigned short), 1, file);
        fclose(file);
    }
    
    TEST_ASSERT_NULL(readImages(path));
    remove(path);
}

void test_openFileAndReadHeaderFailsOnTruncatedHeader(void)
{
    // Test: Datei ist zu kurz für Header
    const char *path = "testTruncated.info2";
    FILE *file = fopen(path, "wb");
    if (file != NULL) {
        // Nur 10 Bytes schreiben (Header ist 24 Bytes)
        const char *fileTag = "__info2_im";
        fwrite(fileTag, 1, 10, file);
        fclose(file);
    }
    
    TEST_ASSERT_NULL(readImages(path));
    remove(path);
}

void test_openFileAndReadHeaderFailsOnMissingCount(void)
{
    // Test: Datei hat Header aber keine Meta Daten
    const char *path = "testMissingCount.info2";
    FILE *file = fopen(path, "wb");
    if (file != NULL) {
        const char *fileTag = "__info2_image_file_format__";
        fwrite(fileTag, sizeof(fileTag[0]), strlen(fileTag), file);
        fclose(file);
    }
    
    TEST_ASSERT_NULL(readImages(path));
    remove(path);
}

void test_openFileAndReadHeaderSucceedsWithValidData(void)
{
    // Test: Valide Datei sollte erfolgreich sein
    const char *path = "testValid.info2";
    prepareImageFile(path, 28, 28, 5, 3);
    
    GrayScaleImageSeries *series = readImages(path);
    TEST_ASSERT_NOT_NULL(series);
    TEST_ASSERT_EQUAL_UINT16(5, series->count);
    TEST_ASSERT_EQUAL_UINT16(28, series->images[0].width);
    TEST_ASSERT_EQUAL_UINT16(28, series->images[0].height);
    
    clearSeries(series);
    remove(path);
}

void test_openFileAndReadHeaderCorrectMetadataOrder(void)
{
    // Test: Metadaten werden in richtiger Reihenfolge gelesen
    const char *path = "testMetadataOrder.info2";
    FILE *file = fopen(path, "wb");
    if (file != NULL) {
        const char *fileTag = "__info2_image_file_format__";
            unsigned short count = 10;
            unsigned short width = 16;   // Anzahl, Breite, Höhe
            unsigned short height = 32;
            unsigned char label = 5;
            unsigned char pixel_data[16*32];
            memset(pixel_data, 128, sizeof(pixel_data));
        
        fwrite(fileTag, sizeof(fileTag[0]), strlen(fileTag), file);
    fwrite(&count, sizeof(unsigned short), 1, file);
    fwrite(&width, sizeof(unsigned short), 1, file);
    fwrite(&height, sizeof(unsigned short), 1, file);
        
        for (int i = 0; i < count; i++) {
            fwrite(pixel_data, 1, 16*32, file);
            fwrite(&label, 1, 1, file);
        }
        fclose(file);
    }
    
    GrayScaleImageSeries *series = readImages(path);
    TEST_ASSERT_NOT_NULL(series);
    TEST_ASSERT_EQUAL_UINT16(10, series->count);
    TEST_ASSERT_EQUAL_UINT16(32, series->images[0].height);  // height korrekt
    TEST_ASSERT_EQUAL_UINT16(16, series->images[0].width);   // width korrekt
    
    clearSeries(series);
    remove(path);
}

void setUp(void) {
    // Falls notwendig, kann hier Vorbereitungsarbeit gemacht werden
}

void tearDown(void) {
    // Hier kann Bereinigungsarbeit nach jedem Test durchgeführt werden
}

int main()
{
    UNITY_BEGIN();
    
    printf("\n============================\nImage input tests\n============================\n");
    
    // Ursprüngliche Tests
    RUN_TEST(test_readImagesReturnsCorrectNumberOfImages);
    RUN_TEST(test_readImagesReturnsCorrectImageWidth);
    RUN_TEST(test_readImagesReturnsCorrectImageHeight);
    RUN_TEST(test_readImagesReturnsCorrectLabels);
    RUN_TEST(test_readImagesReturnsNullOnNotExistingPath);
    RUN_TEST(test_readImagesFailsOnWrongFileTag);
    
    // Neue Tests für kombinierte Funktion (Input-Validierung)
    printf("\n--- Tests für Input-Validierung ---\n");
    RUN_TEST(test_openFileAndReadHeaderFailsOnZeroImageCount);
    RUN_TEST(test_openFileAndReadHeaderFailsOnZeroWidth);
    RUN_TEST(test_openFileAndReadHeaderFailsOnZeroHeight);
    RUN_TEST(test_openFileAndReadHeaderFailsOnTruncatedHeader);
    RUN_TEST(test_openFileAndReadHeaderFailsOnMissingCount);
    RUN_TEST(test_openFileAndReadHeaderSucceedsWithValidData);
    RUN_TEST(test_openFileAndReadHeaderCorrectMetadataOrder);

    return UNITY_END();
}