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

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

//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()
{
    time_t tempo_epoche[MAX_EPOCHE];

    srand(time(NULL));

    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(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);
    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 -1; indice_set++)
        {
            //printf("Qui ci arrivo %d\n", indice_set);
            double **funzioni_attivazione = elabora_funzioni_attivazione(rete_neurale, set.istanze[indice_set], TIPO_FUNZIONE);

            /* 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, funzioni_attivazione[k][j]); */

            byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione);

            double **gradienti = (double **)malloc(sizeof(double *) * NUM_LAYERS);

            // Alloco la dimensione per ogni layer
            for (int indice_layer = 0; indice_layer < NUM_LAYERS; indice_layer++)
            {
                gradienti[indice_layer] = (double *)malloc(sizeof(double) * rete_neurale.layers[indice_layer].size);
            }

            

            // Derivata funzione di perdita
            // printf("output_corretto = %d, previsione: %f\n", output_corretto, funzioni_attivazione[NUM_LAYERS - 1][0]);
            double gradiente_errore = (output_corretto - funzioni_attivazione[NUM_LAYERS - 1][0]);

            errore_totale += pow(gradiente_errore, 2) * 0.5;

            

            // Derivata funzione attivazione
            double derivata_funzione_out = derivata_sigmoide(funzioni_attivazione[NUM_LAYERS - 1][0]);
            // if (derivata_funzione_out == 0.0) derivata_funzione_out = 1;

            // Gradiente del percettrone output
            gradienti[NUM_LAYERS - 1][0] = gradiente_errore * derivata_funzione_out;

            //Crasha nella discesa del gradiente all'immagine indice 16 quando metto troppi percettroni
            discesa_gradiente(rete_neurale, funzioni_attivazione, gradienti, TIPO_FUNZIONE);
            
            

            // A questo punto ho tutti i gradienti dei percettroni, non mi resta che trovare i gradienti dei pesi e correggerli

            // Correggo il livello output
            for (int indice_peso = 0; indice_peso < rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].size; indice_peso++)
            {
                // Determino gradiente del peso
                double gradiente_peso = gradienti[NUM_LAYERS - 1][0] * funzioni_attivazione[NUM_LAYERS - 2][indice_peso];
                rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].pesi[indice_peso] += gradiente_peso * LRE;
            }
            rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].bias += gradienti[NUM_LAYERS - 1][0] * LRE;

            // Applico la correzione dal penultimo layer andando indietro fino al secondo (il primo si fa diverso)
            for (int indice_layer = NUM_LAYERS - 2; indice_layer >= 0; indice_layer--)
            {
                // Applico la correzione a tutti i percettroni del layer dal primo a seguire
                for (int indice_percettrone = 0; indice_percettrone < rete_neurale.layers[indice_layer].size; indice_percettrone++)
                {
                    // Devo prendere il gradiente del percettrone e moltiplicarlo con gli input associati ai pesi
                    if (indice_layer != 0)
                    {
                        correggi_pesi_percettrone_double(&rete_neurale.layers[indice_layer].percettroni[indice_percettrone], indice_layer, funzioni_attivazione, gradienti[indice_layer][indice_percettrone]);
                    }
                    else
                    {
                        correggi_pesi_percettrone_byte(&rete_neurale.layers[0].percettroni[indice_percettrone], set.istanze[indice_set], gradienti[0][indice_percettrone], indice_percettrone);
                    }
                }
            }

            if (previsione(funzioni_attivazione[NUM_LAYERS - 1][0]) == output_corretto)
            {
                corrette++;
            }
        }

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

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

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