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

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

// 1 relu, 2 sigmoide
#define TIPO_FUNZIONE 2

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

void main()
{
    srand(time(NULL));
    time_t tempo_epoche[MAX_EPOCHE];

    /*
        ################# Inizializzazione rete e caricamento Dataset ################################
    */

    Dataset *set_appoggio = get_dataset(file_immagini, file_label);

    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_feed_forward(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
    }
    else
    {
        rete_neurale = *puntatore_rete;
        free(puntatore_rete);
        printf("Caricate impostazioni rete neurale da file\n");
    }

    // rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);

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

    /*
        ################# Addestramento ################################
    */
    int corrette = 0;

    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 < 1/* set.size */; indice_set++)
        {
            double **funzioni_attivazione = elabora_funzioni_attivazione(rete_neurale, set.istanze[indice_set], TIPO_FUNZIONE);

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

            // Derivata funzione di perdita
            double errore = (output_corretto - funzioni_attivazione[rete_neurale.size - 1][0]);

            // Sommo la funzione di perdita a errore_totale per stampare alla fine dell'epoca l'errore medio
            errore_totale += pow(errore, 2) * 0.5;

            double **gradienti = discesa_gradiente(rete_neurale, funzioni_attivazione, errore, TIPO_FUNZIONE);
            aggiorna_pesi(rete_neurale, gradienti, funzioni_attivazione, set.istanze[indice_set]);

            //debug_matrice(&rete_neurale, funzioni_attivazione);
        }

        errore_totale /= set.size;
        double percentuale = (corrette * 100) / set.size;
        printf("Errore: %f, accuratezza: %.2f%, corrette: %d\n", errore_totale, percentuale, corrette);
    }

    // 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);
    }
}

/* if (i == MAX_EPOCHE - 1)
        {
            printf("\nUltima epoca (%d), stato della rete:\n", i);
            double **risultato;
            for (int j = 0; j < 4; j++)
            {
                risultato = elabora_funzioni_attivazione(rete_neurale, set.istanze[j]);
                printf("Input: [%d,%d] -> probabilità: %f -> previsione: %d -> risultato attesto: %d\n", set.istanze[j].dati[0], set.istanze[j].dati[1], risultato[NUM_LAYERS - 1][0], previsione(risultato[NUM_LAYERS - 1][0]), set.istanze[j].classificazione);
                for (int k = 0; k < rete_neurale.size; k++)
                    for (int j = 0; j < rete_neurale.layers[k].size; j++)
                        printf("sigmoide[%d][%d] = %f\n", k, j, risultato[k][j]);
            }
        } */