Algoritmo Calcolo Codice Fiscale

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CalcoloCodiceFiscale
{
    // E' un codice Alfanumerico (composto da lettere e numeri) di 16 caratteri.
    // I primi 15 sono relativi ai [dati personali]
    // ([nome], [cognome], [sesso], [data di nascita] e [luogo di nascita])

    // Una enum definisce un tipo di dato il cui dominio è
    // rappresentato da informazioni numeriche associate
    // a dei valori mnemonici testuali
    public enum GenderType : byte
    {
        Male = 0,
        Female = 40
    }
    public class PersonalData
    {
        // Nome
        public string FirstName { get; set; }
        // Cognome
        public string LastName { get; set; }
        // Sesso
        public GenderType Gender { get; set; }
        // Data di nascita
        public DateTime Birthday { get; set; }
        // Città di nascita
        public string BirthCity { get; set; }
    }

    public class CodiceFiscale
    {
        // E' un codice Alfanumerico (composto da lettere e numeri) di 16 caratteri
        public string Calcola(PersonalData data)
        {
            string result = "";
            // E' composto dai seguenti blocchi:
            //-3 lettere per il cognome
            result += handleLastName(data.LastName);
            //-3 lettere per il nome
            result += handleFirstName(data.FirstName);
            //- l'anno di nascita (numero)
            //- il mese della data di nascita(lettera)
            //- il giorno della data di nascita(numero)
            result += handleBirthday(data.Birthday, data.Gender);
            //- il codice del comune di nascita
            result += handleBirthCity(data.BirthCity);
            //- il carattere di controllo
            // l'ultimo è un carattere di controllo che viene calcolato
            // con delle formule applicate ai precedenti 15 caratteri.
            result += calcCheckCode(result);
            return result;
        }
        // Si comincia con il prendere i caratteri del codice fiscale
        // fin qui calcolato che sono 15, si prendono quelli in posizione
        // pari e si convertono con i numeri corrispondenti della prima
        // tabella.Tutti questi numeri vengono sommati.
        // Allo stesso modo con i caratteri dispari che devono
        // essere convertiti però utilizzando la seconda tabella e
        // vengono tutti sommati.
        // I valori ottenuti vengono a loro volta sommati e
        // il totale viene diviso per 26.
        private char calcCheckCode(string fiscalcode)
        {
            int[] odds =
                { 1, 0, 5, 7, 9, 13, 15, 17, 19, 21, 2, 4, 18, 20,
                 11, 3, 6, 8, 12, 14, 16, 10, 22, 25, 24, 23 };
            int sum = 0;
            for(int index=0; index < 15; ++index)
            {
                char c = fiscalcode[index];
                int depl = char.IsDigit(c) ? c - '0' : c - 'A';
                sum += index % 2 == 0 ? odds[depl] : depl;
            }
            return (char)(sum % 26 + 'A');
        }

        private string handleBirthCity(string birthCity)
        {
            return birthCity;
        }

        // Anno di nascita
        // Per l'anno vengono prese semplicemente le ultime due cifre.
        // Mese
        // Per quanto riguarda il mese c'è una tabella di conversione
        // che riportiamo qui di seguito.
        // Ad ogni mese corrisponde una lettera dell'alfabeto:
        // Giorno
        // In questo caso è sufficiente riportare il numero del giorno,
        // con il particolare che per le donne questo numero
        // dev'essere aumentato di 40!
        private string handleBirthday(DateTime birthday, GenderType gender)
        {
            const string MONTHS = "ABCDEHLMPRST";
            int day = birthday.Day + (int)gender;

            return string.Format("{0:yy}{1}{2:00}",
                birthday, MONTHS[birthday.Month - 1], day);
        }
        // Per il nome il discorso è analogo con la particolarità
        // che se il nome è composto da 4 o più consonanti vengono
        // prese nell'ordine la prima, la terza e la quarta.
        // Anche qui potremmo trovarci nella situazione di un numero
        // di consonanti minore di 3 e allo stesso modo si aggiungo le vocali.
        // Ripetiamo anche qui che se il nome è più corto di 3 lettere
        // è possibile sostituire i caratteri mancanti con delle X.
        // Se il nome fosse composto da più nomi,
        // bisogna considerarlo tutto assieme.
        private string handleFirstName(string firstName)
        {
            string[] cv = separateVowels(firstName);
            // se il nome è composto da 4 o più consonanti vengono
            if (cv[0].Length > 3)
                // vengono prese nell'ordine la prima, la terza e la quarta
                cv[0] = cv[0].Substring(0, 1) + cv[0].Substring(2);
            string result = cv[0] + cv[1] + "XXX";
            return result.Substring(0, 3);
        }
        // Cognome
        // Sono necessari 3 caratteri per rappresentare il cognome,
        // e sono la prima la seconda e la terza consonante del cognome.
        // E' possibile che le consonanti siano meno di tre,
        // in questo caso è possibile aggiungere le vocali nell'ordine
        // in cui compaiono nel cognome.
        // Per cognomi più corti di 3 caratteri,
        // è possibile sostituire il carattere mancante con la lettera X.
        // Chiaramente se ci sono cognomi con più parti,
        // è necessario rimuovere gli spazi e considerare tutto
        // come un cognome unico.
        private string handleLastName(string lastName)
        {
            string[] cv = separateVowels(lastName);
            string result = cv[0] + cv[1] + "XXX";
            return result.Substring(0, 3);
        }
        // metodo che separa le consonanti dalle vocali
        private string[] separateVowels(string text)
        {
            const string VOWELS = "AEIOU";
            string[] result = new string[2];
            for (int index = 0; index < text.Length; ++index)
            {
                char c = char.ToUpperInvariant(text[index]);
                if (char.IsLetter(c))
                    if (VOWELS.Contains(c))
                        result[1] += c;
                    else
                        result[0] += c;
            }
            return result;
        }
    }
}