#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <math.h>

#include "traitementPGM.h"
#include "gfx.h"

void write_error_graphic_file(const char *filename, const uint32_t size_n[],const double error_n[],const uint32_t length_data);
void Integration_numerique(void);
void Convolution_filtrage(void);
void Convolution_test(void);


void write_error_graphic_file(const char *filename, const uint32_t size_n[],const double error_n[],const uint32_t length_data)
{
    FILE *f = fopen(filename, "w");

    for (uint32_t i = 0; i < length_data; i += 1)
    {
        fprintf(f, "%u,%lf\n", size_n[i], error_n[i]);
    }
    fclose(f);
}


void Integration_numerique()
{
    uint32_t size_n[] = {5, 10, 50, 100, 500, 1000};
    double error_n[6];
    for (uint32_t i = 0; i < sizeof(size_n) / sizeof(size_n[0]); i += 1)
    {
        printf("N = %u\n", size_n[i]);
        printf("Res integre : %.5lf\n", interg(1, 5, size_n[i], my_function_x));
        error_n[i] = E_n(size_n[i]);
        printf("E(N) = %lf\nI = %lf\n", error_n[i], VALUE_I);
    }

    write_error_graphic_file("graphique_data.txt", size_n, error_n, 6);
}

void Convolution_test()
{
    matrix m1 = matrix_creat(10,10); 
    matrix m2 = matrix_creat(3,3); 

    int tab []= {1,1,1,1,1,1,1,1,1};

    matrix_from_array(&m2,3,3,tab);

    matrix_print(m2);

    matrix_setValue(&m1,8);

    matrix res = matrix_creat(10,10);

    matrix_print(m1);
    matrix_print(m2);

    convolve_matrix(&res,&m1,&m2,1/(double)9); // For create blur kernel
    matrix_print(res);

    matrix_destroy(&m1);
    matrix_destroy(&m2);
    matrix_destroy(&res);
}

void Convolution_filtrage()
{
    /*
        MALLOC LEAKSANITZIZE
        use only : matrix_create & matrix_free
   */

    char filname[] = "part3_1.pgm";
    char output_image[] = "out.pgm";
    char output_convolve[] = "convolve.pgm";

    pgm img;
    if (pgm_read_from_file(&img, filname) != ok)
    {
        printf("Impossible de lire l'image shouaitée\n");
        return;
    }
    printf("%d %d\n",img.pixels.m,img.pixels.n);
    PrintImagePGM(img, filname);

    // normalise_matrix(&img.pixels,img.max,7);
    // PrintImagePGM(img, filname);

    pgm_write_to_file(&img,output_image);
    // exit(0);
    
    matrix kernel = matrix_creat(3,3);
    // int tab []= {0,0,0,0,1,0,0,0,0};
    // int tab []= {1,1,1,1,1,1,1,1,1};
    // int tab[] = {0,-1,0,-1,5,-1,0,-1,0};
    matrix_from_array(&kernel,3,3,tab);
    matrix_print(kernel);

    pgm res;
    res.max = img.max;
    res.pixels = matrix_creat(img.pixels.m,img.pixels.n);

    // normalise_matrix(&img.pixels,img.max,7);

    convolve_matrix(&res.pixels,&img.pixels,&kernel,1);

    // normalise_matrix(&res.pixels,res.max,7);

    PrintImagePGM(res, filname);

    pgm_write_to_file(&res,output_convolve);

    matrix_destroy(&img.pixels);
    matrix_destroy(&res.pixels);
    matrix_destroy(&kernel);
}

int main()
{
    printf("TP math - Integrales\n");

    //Integration_numerique();
    
    Convolution_filtrage();
    //Convolution_test();

    return EXIT_SUCCESS;
}