#include <time.h>
#include "percettroni.h"

// Scelgo quale categoria voglio identificare. nel caso dello xor -1
#define CATEGORIA 7
#define NUM_LAYERS 7
#define PERCETTRONI_LAYER_0 128
#define MAX_EPOCHE 50

byte get_out_corretto(byte);
void stampa_layer_indirizzo(Layer *);
void stampa_tempo(time_t[], int);

void main()
{
    time_t tempo_epoche[MAX_EPOCHE];

    srand(time(NULL));

    Dataset *set_appoggio = get_dataset(file_immagini, file_label); //get_dataset(file_immagini);

    if (set_appoggio == NULL)
        return;
    Dataset set = *set_appoggio;
    free(set_appoggio);

    ReteNeurale rete_neurale;
    ReteNeurale *puntatore_rete = caricaReteNeurale(file_pesi);
    if (puntatore_rete == NULL)
    {
        rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
    }
    else
    {
        rete_neurale = *puntatore_rete;
        free(puntatore_rete);
        printf("Caricate impostazioni rete neurale da file\n");
    }

    int corrette = 0;

    printf("Numero elementi nel dataset: %d\n", set.size);

    // ADDESTRAMENTO
    for (int i = 0; i < MAX_EPOCHE; i++)
    {
        printf("Epoca %d\n", i);
        stampa_tempo(tempo_epoche, i);
        corrette = 0;
        double errore_totale = 0.0;
        
        for (int indice_set = 0; indice_set < set.size; indice_set++)
        {
            double **sigmoidi = elabora_sigmoidi(rete_neurale, set.istanze[indice_set]);

            byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione);
            if (previsione(sigmoidi[rete_neurale.size - 1][0]) == output_corretto)
                corrette++;

            // Derivata funzione di perdita
            double gradiente_errore = (output_corretto - sigmoidi[rete_neurale.size - 1][0]);
            errore_totale += pow(gradiente_errore, 2);

            double **gradienti = elabora_gradienti(rete_neurale, gradiente_errore, sigmoidi);

            aggiorna_pesi(&rete_neurale, sigmoidi, gradienti, set.istanze[indice_set]);

        }

        printf("Errore: %f, risposte corrette: %d%\n", errore_totale / set.size, (corrette * 100) / set.size);
    }

    salvaReteNeurale(file_pesi, &rete_neurale);
}

// Questa funzione ritorna 1 se la categoria è quella che voglio individuare, altrimenti 0
byte get_out_corretto(byte categoria)
{
    if (CATEGORIA != -1)
    {
        if (categoria == CATEGORIA)
            return 1;
        else
            return 0;
    }
    else
        return categoria;
}

void stampa_layer_indirizzo(Layer *layer)
{
    for (int i = 0; i < layer->size; i++)
    {
        printf("Percettrone %d ->", i);
        for (int j = 0; j < layer->percettroni->size; j++)
        {
            printf("\t peso %d, valore: %f", j, layer->percettroni[i].pesi[j]);
            layer->percettroni[i].pesi[j] += 1;
        }
        printf("\n");
    }
}

void stampa_tempo(time_t tempo_epoche[], int i)
{

    time(&tempo_epoche[i]);
    if (i > 0)
    {
        double tempo_trascorso_epoca = difftime(tempo_epoche[i], tempo_epoche[i - 1]);
        double tempo_trascorso_totale = difftime(tempo_epoche[i], tempo_epoche[0]);
        int minuti_epoca = (int)tempo_trascorso_epoca / 60;
        int secondi_epoca = (int)tempo_trascorso_epoca % 60;
        int minuti_totali = (int)tempo_trascorso_totale / 60;
        int secondi_totali = (int)tempo_trascorso_totale % 60;
        printf("Tempo dall'epoca precedente: %d:%d\n", minuti_epoca, secondi_epoca);
        printf("Tempo dall'inizio: %d:%d\n", minuti_totali, secondi_totali);
    }
}