#include <stdio.h>
#include <stdlib.h>

struct nodoLista {
    int valore;
    struct nodoLista *nextPtr;
};

typedef struct nodoLista Lista;

// Prototipi
void suf_insert(Lista **ptrPtr, int val);
void print_list(Lista *ptr);
void reverse_list(Lista **ptrPtr);

int main() {
    Lista *mia_lista = NULL;
    
    // Creiamo una lista ordinata
    suf_insert(&mia_lista, 10);
    suf_insert(&mia_lista, 20);
    suf_insert(&mia_lista, 30);
    suf_insert(&mia_lista, 40);
    
    printf("Lista Originale (Atteso: 10 20 30 40):\n");
    print_list(mia_lista);
    
    // Chiamata al Boss Finale
    reverse_list(&mia_lista);
    
    printf("Lista Invertita (Atteso: 40 30 20 10):\n");
    print_list(mia_lista);
    
    return 0;
}

// Funzione fornita dal professore
void suf_insert(Lista **ptrPtr, int val) {
    while(*ptrPtr != NULL) {
        ptrPtr = &((*ptrPtr)->nextPtr);
    }
    Lista *tmp = (Lista *)malloc(sizeof(Lista));
    tmp->valore = val;
    tmp->nextPtr = NULL;
    *ptrPtr = tmp;
}

void print_list(Lista *ptr) {
    while(ptr != NULL) {
        printf("%d ", ptr->valore);
        ptr = ptr->nextPtr;
    }
    printf("\n");
}

/* ========================================================================= */
/* ESERCIZIO DELLO STUDENTE                                                  */
/* ========================================================================= */

/* PRE:  'ptrPtr' è l'indirizzo della testa della lista.
 * POST: L'ordine dei nodi nella lista viene invertito fisicamente in memoria.
 * Non viene allocata né liberata memoria (no malloc, no free).
 * Il doppio puntatore viene aggiornato per puntare alla nuova testa.
 */


void reverse_list(Lista **ptrPtr) {
    // Se la lista è vuota o ha un solo elemento, non c'è nulla da invertire
    if (ptrPtr == NULL || *ptrPtr == NULL) {
        return;
    }
    
    Lista *prev = NULL;        // All'inizio non c'è nulla prima della testa
    Lista *current = *ptrPtr;  // Partiamo dal primo nodo della lista
    Lista *next = NULL;        // Servirà a salvare il nodo successivo
    
    while (current != NULL) {
        // PASSO 1: Salvo il riferimento al prossimo nodo prima di staccare la freccia
        next = current->nextPtr;
        
        // PASSO 2: Inverto il puntatore! Il nodo corrente adesso punta a quello dietro
        current->nextPtr = prev;
        
        // PASSO 3: Sposto i puntatori in avanti per il prossimo giro
        prev = current;
        current = next;
    }
    
    // PASSO FINALISSIMO: Alla fine del ciclo, 'prev' si troverà sull'ex-ultimo nodo (il 40).
    // Aggiorniamo la testa della lista originale facendola puntare lì!
    *ptrPtr = prev;
}