🚗 Parco Auto: Classi e File I/O

using System;
using System.Collections.Generic;
using System.Windows.Forms;

namespace ParcoAuto
{
    public partial class Form1 : Form
    {
        // ═══════════════════════════════════════
        // VARIABILE GLOBALE: Lista di Automobile
        // ═══════════════════════════════════════
        // Questa lista contiene tutti gli oggetti Automobile
        private List<Automobile> listaAuto;

        public Form1()
        {
            InitializeComponent();
            
            // Crea una nuova lista vuota
            listaAuto = new List<Automobile>();
            
            // Riempi la ComboBox con i tipi di carburante
            InizializzaCarburanti();
        }

        // ═══════════════════════════════════════
        // Riempi la ComboBox con i carburanti
        // ═══════════════════════════════════════
        private void InizializzaCarburanti()
        {
            cmbCarburante.Items.Add("Scegli carburante");
            cmbCarburante.Items.Add("Benzina");
            cmbCarburante.Items.Add("Diesel");
            cmbCarburante.Items.Add("GPL");
            cmbCarburante.Items.Add("Metano");
            cmbCarburante.Items.Add("Elettrica");
            cmbCarburante.Items.Add("Ibrida");
            
            // Seleziona il primo elemento
            cmbCarburante.SelectedIndex = 0;
        }

        // ═══════════════════════════════════════
        // EVENTO: Aggiungi auto (clic su pulsante)
        // ═══════════════════════════════════════
        private void btnAggiungi_Click(object sender, EventArgs e)
        {
            // STEP 1: Controlla che tutti i campi siano compilati
            if (!ControllaCampi())
            {
                return;  // Esci dal metodo se i campi non sono OK
            }

            // STEP 2: Controlla che la cilindrata sia un numero valido
            if (!ValidaCilindrata(txtCilindrata.Text))
            {
                return;  // Esci se la cilindrata non è valida
            }

            // STEP 3: Prendi i valori dalle TextBox
            string modello = txtModello.Text;
            int cilindrata = Convert.ToInt32(txtCilindrata.Text);
            string carburante = cmbCarburante.SelectedItem.ToString();

            // STEP 4: CREA UN NUOVO OGGETTO Automobile
            // Il costruttore riceve i 3 parametri
            Automobile nuovaAuto = new Automobile(modello, cilindrata, carburante);
            
            // STEP 5: Aggiungi l'oggetto alla lista
            listaAuto.Add(nuovaAuto);
            
            // STEP 6: Aggiorna quello che vedi sullo schermo
            AggiornaListaAuto();     // Aggiorna la ListBox
            AggiornaStatistiche();    // Aggiorna il contatore
            PulisciCampi();           // Pulisci le TextBox
            
            // STEP 7: Mostra messaggio di conferma
            MessageBox.Show("Auto aggiunta con successo!", 
                          "Operazione Completata",
                          MessageBoxButtons.OK, 
                          MessageBoxIcon.Information);
        }

        // ═══════════════════════════════════════
        // Controlla che i campi siano compilati
        // ═══════════════════════════════════════
        private bool ControllaCampi()
        {
            // Controlla modello
            if (string.IsNullOrEmpty(txtModello.Text))
            {
                MessageBox.Show("Devi inserire il modello dell'auto!",
                              "Campo Mancante",
                              MessageBoxButtons.OK,
                              MessageBoxIcon.Warning);
                return false;
            }
            
            // Controlla cilindrata
            if (string.IsNullOrEmpty(txtCilindrata.Text))
            {
                MessageBox.Show("Devi inserire la cilindrata!",
                              "Campo Mancante",
                              MessageBoxButtons.OK,
                              MessageBoxIcon.Warning);
                return false;
            }
            
            // Controlla carburante
            if (cmbCarburante.SelectedIndex == 0)
            {
                MessageBox.Show("Devi selezionare il tipo di carburante!",
                              "Campo Mancante",
                              MessageBoxButtons.OK,
                              MessageBoxIcon.Warning);
                return false;
            }
            
            // Se arrivo qui, tutti i campi sono OK
            return true;
        }

        // ═══════════════════════════════════════
        // Controlla che la cilindrata sia valida
        // ═══════════════════════════════════════
        private bool ValidaCilindrata(string testo)
        {
            try
            {
                // Prova a convertire il testo in numero
                int cilindrata = Convert.ToInt32(testo);
                
                // Controlla che sia in un range sensato
                if (cilindrata <= 0 || cilindrata > 10000)
                {
                    MessageBox.Show("La cilindrata deve essere tra 1 e 10000 cc!",
                                  "Valore Non Valido",
                                  MessageBoxButtons.OK,
                                  MessageBoxIcon.Warning);
                    return false;
                }
                
                return true;  // Il valore è OK
            }
            catch
            {
                // Se la conversione fallisce (es: "abc" non è un numero)
                MessageBox.Show("Devi inserire un numero valido per la cilindrata!",
                              "Errore",
                              MessageBoxButtons.OK,
                              MessageBoxIcon.Error);
                return false;
            }
        }
    }
}

        // ═══════════════════════════════════════
        // Aggiorna la ListBox con tutte le auto
        // ═══════════════════════════════════════
        private void AggiornaListaAuto()
        {
            // STEP 1: Pulisci la ListBox
            lstAuto.Items.Clear();
            
            // STEP 2: Aggiungi ogni auto dalla lista
            foreach (Automobile auto in listaAuto)
            {
                // Quando aggiungi un oggetto Automobile,
                // la ListBox chiama automaticamente il metodo ToString()
                // che ritorna: "Fiat 500 - 1200cc - Benzina"
                lstAuto.Items.Add(auto);
            }
        }

        // ═══════════════════════════════════════
        // Aggiorna il contatore delle auto
        // ═══════════════════════════════════════
        private void AggiornaStatistiche()
        {
            // Conta quante auto ci sono nella lista
            int numeroAuto = listaAuto.Count;
            
            // Mostra il numero nella Label
            lblTotaleAuto.Text = $"Totale auto nel parco: {numeroAuto}";
        }

        // ═══════════════════════════════════════
        // Pulisci tutti i campi del form
        // ═══════════════════════════════════════
        private void PulisciCampi()
        {
            txtModello.Text = "";
            txtCilindrata.Text = "";
            cmbCarburante.SelectedIndex = 0;
            
            // Metti il cursore sul primo campo
            txtModello.Focus();
        }

        // ═══════════════════════════════════════
        // EVENTO: Rimuovi auto (clic su pulsante)
        // ═══════════════════════════════════════
        private void btnRimuovi_Click(object sender, EventArgs e)
        {
            // Controlla se hai selezionato un'auto
            if (lstAuto.SelectedIndex == -1)
            {
                MessageBox.Show("Devi selezionare un'auto da rimuovere!",
                              "Nessuna Selezione",
                              MessageBoxButtons.OK,
                              MessageBoxIcon.Warning);
                return;
            }

            // Prendi l'auto selezionata dalla lista
            Automobile autoSelezionata = listaAuto[lstAuto.SelectedIndex];
            
            // Salva il modello per il messaggio
            string modello = autoSelezionata.Modello;
            
            // Rimuovi l'auto dalla lista
            listaAuto.RemoveAt(lstAuto.SelectedIndex);
            
            // Aggiorna la visualizzazione
            AggiornaListaAuto();
            AggiornaStatistiche();
            
            // Mostra messaggio di conferma
            MessageBox.Show($"L'auto '{modello}' è stata rimossa!",
                          "Auto Rimossa",
                          MessageBoxButtons.OK,
                          MessageBoxIcon.Information);
        }
    }
}

// In cima al file, aggiungi questo:
using System.IO;  // Necessario per lavorare con i file!

// ═══════════════════════════════════════
// EVENTO: Salva in TXT
// ═══════════════════════════════════════
private void btnSalvaTXT_Click(object sender, EventArgs e)
{
    // STEP 1: Usa try-catch per gestire eventuali errori
    // (es: disco pieno, permessi mancanti, ecc.)
    try
    {
        // STEP 2: Crea/Apri il file per scrivere
        // "parco_auto.txt" è il nome del file
        // Se non esiste, viene creato
        // Se esiste, viene sovrascritto
        using (StreamWriter scrittore = new StreamWriter("parco_auto.txt"))
        {
            // STEP 3: Scrivi l'intestazione
            scrittore.WriteLine("═══════════════════════════════════════");
            scrittore.WriteLine("     PARCO AUTO - ELENCO COMPLETO");
            scrittore.WriteLine("═══════════════════════════════════════");
            scrittore.WriteLine("");  // Riga vuota
            
            // STEP 4: Scrivi ogni auto
            int numero = 1;  // Contatore per numerare le auto
            
            foreach (Automobile auto in listaAuto)
            {
                // Scrivi il numero e i dati dell'auto
                scrittore.WriteLine($"{numero}. {auto.Stampa()}");
                scrittore.WriteLine("");  // Riga vuota dopo ogni auto
                
                numero++;  // Passa alla prossima auto
            }
            
            // STEP 5: Scrivi il totale
            scrittore.WriteLine("───────────────────────────────────────");
            scrittore.WriteLine($"Totale auto: {listaAuto.Count}");
            scrittore.WriteLine("═══════════════════════════════════════");
            
        } // ← Il file viene chiuso automaticamente qui!
        
        // STEP 6: Mostra messaggio di successo
        MessageBox.Show("Parco auto salvato nel file parco_auto.txt!",
                      "Salvataggio Completato",
                      MessageBoxButtons.OK,
                      MessageBoxIcon.Information);
    }
    catch (Exception errore)
    {
        // Se qualcosa va storto, mostra il messaggio di errore
        MessageBox.Show($"Errore durante il salvataggio: {errore.Message}",
                      "Errore",
                      MessageBoxButtons.OK,
                      MessageBoxIcon.Error);
    }
}

// ═══════════════════════════════════════
// EVENTO: Salva in CSV
// ═══════════════════════════════════════
private void btnSalvaCSV_Click(object sender, EventArgs e)
{
    try
    {
        // Apri/Crea il file CSV
        using (StreamWriter scrittore = new StreamWriter("parco_auto.csv"))
        {
            // STEP 1: Scrivi l'intestazione (nomi delle colonne)
            // Usiamo il punto e virgola (;) come separatore
            scrittore.WriteLine("Modello;Cilindrata;Carburante");
            
            // STEP 2: Scrivi ogni auto come una riga
            foreach (Automobile auto in listaAuto)
            {
                // Costruisci la riga con i dati separati da ;
                string riga = $"{auto.Modello};{auto.Cilindrata};{auto.Carburante}";
                scrittore.WriteLine(riga);
            }
        }
        
        // Mostra messaggio di successo
        MessageBox.Show("File CSV salvato! Puoi aprirlo con Excel.",
                      "Salvataggio Completato",
                      MessageBoxButtons.OK,
                      MessageBoxIcon.Information);
    }
    catch (Exception errore)
    {
        MessageBox.Show($"Errore: {errore.Message}",
                      "Errore",
                      MessageBoxButtons.OK,
                      MessageBoxIcon.Error);
    }
}

using System.IO;  // ← Necessario per File.Exists()

// Controlla se il file esiste
if (File.Exists("automobile.csv"))
{
    // ✅ Il file esiste, puoi leggerlo
    Console.WriteLine("File trovato!");
}
else
{
    // ❌ Il file NON esiste
    MessageBox.Show("File non trovato! Devi salvare prima.");
}

// ═══════════════════════════════════════════════
// Legge TUTTO il contenuto del file
// ═══════════════════════════════════════════════
private void btnLeggiTutto_Click(object sender, EventArgs e)
{
    // STEP 1: Controlla se esiste
    if (!File.Exists("parco_auto.txt"))
    {
        MessageBox.Show("File non trovato!");
        return;
    }

    try
    {
        // STEP 2: Apri il file in LETTURA
        using (StreamReader lettore = new StreamReader("parco_auto.txt"))
        {
            // STEP 3: Leggi TUTTO il contenuto
            string tuttoIlTesto = lettore.ReadToEnd();
            
            // STEP 4: Mostra il contenuto
            MessageBox.Show(tuttoIlTesto, "Contenuto File");
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Errore: {ex.Message}");
    }
}

// ═══════════════════════════════════════════════
// Legge il file riga per riga
// ═══════════════════════════════════════════════
private void btnLeggiRighe_Click(object sender, EventArgs e)
{
    if (!File.Exists("parco_auto.txt"))
    {
        MessageBox.Show("File non trovato!");
        return;
    }

    try
    {
        using (StreamReader lettore = new StreamReader("parco_auto.txt"))
        {
            // Leggi riga per riga finché non arrivi alla fine
            while (!lettore.EndOfStream)
            {
                // Leggi UNA riga
                string riga = lettore.ReadLine();
                
                // Elabora la riga (es: mostrala)
                Console.WriteLine(riga);
            }
        }
        
        MessageBox.Show("File letto con successo!");
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Errore: {ex.Message}");
    }
}

// ═══════════════════════════════════════════════
// EVENTO: Carica auto da file CSV
// ═══════════════════════════════════════════════
private void btnCaricaCSV_Click(object sender, EventArgs e)
{
    // STEP 1: Controlla se il file esiste
    if (!File.Exists("automobile.csv"))
    {
        MessageBox.Show("File automobile.csv non trovato!\n" +
                      "Salva prima alcune auto con il pulsante 'Salva CSV'.",
                      "File Non Trovato",
                      MessageBoxButtons.OK,
                      MessageBoxIcon.Warning);
        return;
    }

    try
    {
        // STEP 2: Pulisci la lista attuale
        // (rimuovi tutte le auto che ci sono ora)
        listaAuto.Clear();
        
        int autoCaricate = 0;   // Contatore auto caricate
        int rigaCorrente = 0;   // Numero riga attuale
        
        // STEP 3: Apri il file in lettura
        using (StreamReader lettore = new StreamReader("automobile.csv"))
        {
            // STEP 4: Salta la prima riga (intestazione)
            // Prima riga: "Modello;Cilindrata;Carburante;Prezzo"
            if (!lettore.EndOfStream)
            {
                string intestazione = lettore.ReadLine();
                rigaCorrente++;
                // Non usiamo questa riga, era solo l'intestazione
            }
            
            // STEP 5: Leggi tutte le altre righe (i dati veri)
            while (!lettore.EndOfStream)
            {
                rigaCorrente++;
                string riga = lettore.ReadLine();
                
                // STEP 6: Salta righe vuote
                if (string.IsNullOrWhiteSpace(riga))
                    continue;
                
                try
                {
                    // STEP 7: Dividi la riga in parti con Split
                    // Es: "Fiat 500;1200;Benzina;15000"
                    string[] parti = riga.Split(';');
                    
                    // STEP 8: Controlla che ci siano esattamente 4 parti
                    if (parti.Length != 4)
                    {
                        MessageBox.Show($"Riga {rigaCorrente} non valida: {riga}",
                                      "Attenzione",
                                      MessageBoxButtons.OK,
                                      MessageBoxIcon.Warning);
                        continue;  // Salta questa riga e vai alla prossima
                    }
                    
                    // STEP 9: Estrai i dati dalle parti
                    string modello = parti[0];               // "Fiat 500"
                    int cilindrata = Convert.ToInt32(parti[1]);      // 1200
                    string carburante = parti[2];            // "Benzina"
                    double prezzo = Convert.ToDouble(parti[3]);      // 15000.0
                    
                    // STEP 10: Crea un nuovo oggetto Automobile
                    Automobile auto = new Automobile(modello, cilindrata, 
                                                    carburante, prezzo);
                    
                    // STEP 11: Aggiungi l'auto alla lista
                    listaAuto.Add(auto);
                    autoCaricate++;
                }
                catch (FormatException)
                {
                    // Errore di conversione (es: "ABC" invece di un numero)
                    MessageBox.Show($"Errore riga {rigaCorrente}: dati non validi",
                                  "Errore Formato",
                                  MessageBoxButtons.OK,
                                  MessageBoxIcon.Error);
                }
                catch (Exception ex)
                {
                    // Altri errori imprevisti
                    MessageBox.Show($"Errore riga {rigaCorrente}: {ex.Message}",
                                  "Errore",
                                  MessageBoxButtons.OK,
                                  MessageBoxIcon.Error);
                }
            }
        } // ← Il file si chiude automaticamente qui
        
        // STEP 12: Aggiorna la visualizzazione
        AggiornaListaAuto();
        AggiornaStatistiche();
        
        // STEP 13: Mostra messaggio di successo
        MessageBox.Show($"✅ Caricate {autoCaricate} auto con successo!",
                      "Caricamento Completato",
                      MessageBoxButtons.OK,
                      MessageBoxIcon.Information);
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Errore durante il caricamento: {ex.Message}",
                      "Errore",
                      MessageBoxButtons.OK,
                      MessageBoxIcon.Error);
    }
}

public partial class Form1 : Form
{
    private List<Automobile> listaAuto;
    private int indiceModifica = -1;

    public Form1()
    {
        InitializeComponent();
        
        // Inizializza la lista vuota
        listaAuto = new List<Automobile>();
        
        // Popola la ComboBox con i carburanti
        InizializzaCarburanti();
        
        // ═══════════════════════════════════════════════
        // CARICA I DATI AUTOMATICAMENTE ALL'AVVIO
        // ═══════════════════════════════════════════════
        CaricaDatiDaFile();
    }
    
    // ═══════════════════════════════════════════════
    // Metodo per caricare i dati all'avvio
    // ═══════════════════════════════════════════════
    private void CaricaDatiDaFile()
    {
        // Se il file non esiste, esci silenziosamente
        // (è la prima volta che usi il programma)
        if (!File.Exists("automobile.csv"))
        {
            return;  // Lista rimane vuota
        }

        try
        {
            using (StreamReader lettore = new StreamReader("automobile.csv"))
            {
                // Salta intestazione
                if (!lettore.EndOfStream)
                {
                    lettore.ReadLine();
                }
                
                // Carica tutte le auto
                while (!lettore.EndOfStream)
                {
                    string riga = lettore.ReadLine();
                    
                    // Salta righe vuote
                    if (string.IsNullOrWhiteSpace(riga))
                        continue;
                    
                    try
                    {
                        string[] parti = riga.Split(';');
                        
                        // Verifica che ci siano 4 parti
                        if (parti.Length == 4)
                        {
                            string modello = parti[0];
                            int cilindrata = Convert.ToInt32(parti[1]);
                            string carburante = parti[2];
                            double prezzo = Convert.ToDouble(parti[3]);
                            
                            Automobile auto = new Automobile(modello, cilindrata, 
                                                            carburante, prezzo);
                            listaAuto.Add(auto);
                        }
                    }
                    catch
                    {
                        // Salta righe con errori (continua con le altre)
                        continue;
                    }
                }
            }
            
            // Aggiorna la visualizzazione
            AggiornaListaAuto();
            AggiornaStatistiche();
        }
        catch
        {
            // Se c'è un errore generale, ignora
            // (lista rimane vuota, non crashare il programma)
        }
    }
}

// ═══════════════════════════════════════
// EVENTO: Ordina le auto per modello
// ═══════════════════════════════════════
private void btnOrdina_Click(object sender, EventArgs e)
{
    // Controlla se ci sono auto da ordinare
    if (listaAuto.Count == 0)
    {
        MessageBox.Show("Non ci sono auto da ordinare!",
                      "Lista Vuota",
                      MessageBoxButtons.OK,
                      MessageBoxIcon.Information);
        return;
    }
    
    // Ordina la lista in ordine alfabetico per modello
    // Sort() usa il metodo CompareTo per confrontare le stringhe
    listaAuto.Sort((auto1, auto2) => auto1.Modello.CompareTo(auto2.Modello));
    
    // Aggiorna la visualizzazione
    AggiornaListaAuto();
    
    // Mostra messaggio
    MessageBox.Show("Auto ordinate per modello in ordine alfabetico!",
                  "Ordinamento Completato",
                  MessageBoxButtons.OK,
                  MessageBoxIcon.Information);
}

public class Automobile
{
    // ─────────────────────────────────────────────────────────
    // PRIMA usavi "private" → SOLO questa classe poteva vederli
    // ORA usi "protected" → anche le classi FIGLIE possono vederli
    // Dall'esterno (Form, altri) rimangono comunque nascosti!
    // ─────────────────────────────────────────────────────────
    protected string _modello;        // ← protected, non private
    protected int _cilindrata;        // ← protected, non private
    protected string _carburante;     // ← protected, non private

    // Le PROPRIETÀ e i METODI pubblici rimangono uguali
    public string Modello
    {
        get { return _modello; }
        set { if (!string.IsNullOrEmpty(value)) _modello = value; }
    }
    public int Cilindrata
    {
        get { return _cilindrata; }
        set { if (value >= 500 && value <= 10000) _cilindrata = value; }
    }
    public string Carburante
    {
        get { return _carburante; }
        set { if (!string.IsNullOrEmpty(value)) _carburante = value; }
    }

    // Il costruttore rimane uguale
    public Automobile(string modello, int cilindrata, string carburante)
    {
        Modello = modello;
        Cilindrata = cilindrata;
        Carburante = carburante;
    }

    // ─────────────────────────────────────────────────────────
    // IMPORTANTE: aggiungi "virtual" ai metodi che le figlie
    // potranno personalizzare (override)
    // ─────────────────────────────────────────────────────────
    public virtual string Stampa()
    {
        return $"{Modello} - {Cilindrata}cc - {Carburante}";
    }

    public override string ToString()
    {
        return Stampa();
    }
}

using System;
using System.Windows.Forms;

namespace ParcoAuto
{
    // ═══════════════════════════════════════════════════
    //  AutoElettrica ESTENDE Automobile
    //  Il ":" indica "eredita da"
    //  Leggi: "AutoElettrica è un tipo di Automobile"
    // ═══════════════════════════════════════════════════
    public class AutoElettrica : Automobile
    {
        // ─────────────────────────────────────────────
        // CAMPI PRIVATI propri di AutoElettrica
        // (quelli di Automobile li ha già ereditati!)
        // ─────────────────────────────────────────────
        private int _autonomiaKm;
        private int _percentualeBatteria;

        // ─────────────────────────────────────────────
        // PROPRIETÀ proprie di AutoElettrica
        // ─────────────────────────────────────────────
        public int AutonomiaKm
        {
            get { return _autonomiaKm; }
            set
            {
                if (value >= 50 && value <= 1000) { _autonomiaKm = value; } else { MessageBox.Show("Autonomia deve essere tra 50 e 1000 km!", "ERRORE", MessageBoxButtons.OK, MessageBoxIcon.Error); } } } public int PercentualeBatteria { get { return _percentualeBatteria; } set { if (value >= 0 && value <= 100)
                    _percentualeBatteria = value;
                else
                    MessageBox.Show("Percentuale batteria deve essere tra 0 e 100!",
                                  "ERRORE", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        // ─────────────────────────────────────────────
        // PROPRIETÀ CALCOLATA: km rimasti con la carica attuale
        // ─────────────────────────────────────────────
        public double KmRimasti
        {
            get { return _autonomiaKm * (_percentualeBatteria / 100.0); }
        }

        // ─────────────────────────────────────────────
        // COSTRUTTORE della classe figlia
        // Deve chiamare il costruttore del GENITORE con "base(...)"
        // ─────────────────────────────────────────────
        public AutoElettrica(string modello, int autonomiaKm, int percentualeBatteria)
            : base(modello, 0, "Elettrica")   // ← chiama Automobile(modello, 0, "Elettrica")
        {
            // Dopo che il costruttore base ha fatto il suo lavoro,
            // impostiamo le proprietà specifiche di AutoElettrica
            AutonomiaKm = autonomiaKm;
            PercentualeBatteria = percentualeBatteria;
        }

        // ─────────────────────────────────────────────
        // OVERRIDE di Stampa() → versione personalizzata
        // Sostituisce la versione del genitore
        // ─────────────────────────────────────────────
        public override string Stampa()
        {
            return $"{Modello} [⚡ Elettrica] - Autonomia: {AutonomiaKm}km - " +
                   $"Batteria: {PercentualeBatteria}% ({KmRimasti:F0}km rimasti)";
        }
        // ToString() NON serve riscriverlo! Chiama già Stampa()
        // che ora è la versione override di AutoElettrica ✅
    }
}

namespace ParcoAuto
{
    public class AutoSportiva : Automobile
    {
        private int _cavalliVapore;
        private bool _hasTurbo;

        public int CavalliVapore
        {
            get { return _cavalliVapore; }
            set
            {
                if (value >= 100 && value <= 2000)
                    _cavalliVapore = value;
                else
                    MessageBox.Show("Cavalli vapore devono essere tra 100 e 2000!",
                                  "ERRORE", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        public bool HasTurbo
        {
            get { return _hasTurbo; }
            set { _hasTurbo = value; }
        }

        // Costruttore: chiama base per modello, cilindrata, carburante
        public AutoSportiva(string modello, int cilindrata, string carburante,
                            int cavalliVapore, bool hasTurbo)
            : base(modello, cilindrata, carburante)
        {
            CavalliVapore = cavalliVapore;
            HasTurbo = hasTurbo;
        }

        // Override personalizzato per AutoSportiva
        public override string Stampa()
        {
            string turbo = HasTurbo ? " [TURBO]" : "";
            return $"{Modello} [🏎️ Sport]{turbo} - {Cilindrata}cc - " +
                   $"{CavalliVapore}cv - {Carburante}";
        }
    }
}

private void InizializzaTipiAuto()
{
    cmbTipoAuto.Items.Add("Standard");
    cmbTipoAuto.Items.Add("Elettrica");
    cmbTipoAuto.Items.Add("Sportiva");
    cmbTipoAuto.SelectedIndex = 0;
}

private void btnAggiungi_Click(object sender, EventArgs e)
{
    if (!ControllaCampi()) return;
    if (!ValidaCilindrata(txtCilindrata.Text)) return;

    string modello    = txtModello.Text;
    int cilindrata    = Convert.ToInt32(txtCilindrata.Text);
    string carburante = cmbCarburante.SelectedItem.ToString();
    string tipoScelto = cmbTipoAuto.SelectedItem.ToString();

    // Variabile di tipo BASE → può contenere qualsiasi figlia
    Automobile nuovaAuto;

    // Crea il tipo giusto in base alla scelta dell'utente
    if (tipoScelto == "Elettrica")
    {
        // Chiedi i dati specifici per l'elettrica
        int autonomia = 400;     // Potresti leggerli da una TextBox dedicata
        int batteria = 100;
        nuovaAuto = new AutoElettrica(modello, autonomia, batteria);
    }
    else if (tipoScelto == "Sportiva")
    {
        int cv = 300;            // Anche questi da TextBox dedicate
        bool turbo = false;
        nuovaAuto = new AutoSportiva(modello, cilindrata, carburante, cv, turbo);
    }
    else
    {
        // Standard
        nuovaAuto = new Automobile(modello, cilindrata, carburante);
    }

    // Aggiunge alla lista (polimorfismo: sempre List<Automobile>!)
    listaAuto.Add(nuovaAuto);

    // Aggiorna - funziona per TUTTI i tipi grazie al polimorfismo
    AggiornaListaAuto();
    AggiornaStatistiche();
    PulisciCampi();
}

private void AggiornaStatistiche()
{
    int totale      = listaAuto.Count;
    int standard    = 0;
    int elettriche  = 0;
    int sportive    = 0;

    foreach (Automobile auto in listaAuto)
    {
        if (auto is AutoElettrica) elettriche++;
        else if (auto is AutoSportiva) sportive++;
        else standard++;
    }

    lblTotaleAuto.Text = $"Totale: {totale} " +
                         $"(Standard: {standard} | " +
                         $"⚡ Elettriche: {elettriche} | " +
                         $"🏎️ Sportive: {sportive})";
}