Calcolo del Codice Fiscale

package corso.java;

import java.util.Calendar;

public class Program {
    // Calcolare il codice fiscale di una persona

    // Cos'è un Codice Fiscale? Cosa si intende?
    // 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])
    // mentre l'ultimo è un carattere di controllo che viene calcolato con
    // delle formule applicate ai precedenti 15 caratteri.
    static String calcolaCodiceFiscale(String nome, String cognome, char sesso, java.util.Date datanascita,
            String comunenascita) {
        String risultato = ""; // parto da un risultato vuoto
        // - 3 lettere per il cognome
        risultato = risultato + letterePerIlCognome(cognome);
        // - 3 lettere per il nome
        risultato += letterePerIlNome(nome);
        // - l'anno di nascita (numero)
        // - il mese della data di nascita (lettera)
        // - il giorno della data di nascita (numero)
        risultato += letterePerData(datanascita, sesso);
        // - il codice del comune di nascita
        risultato += comunenascita.substring(0, 4).toUpperCase();
        // - il carattere di controllo
        risultato += calcolaCodiceControllo(risultato);
        return risultato;
    }

    // Calcolo del codice di controllo
    static char calcolaCodiceControllo(String codfisc) {
        // 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.
        // ***
        // DA UNA ANALISI DELLA TABELLA SI RICAVA CHE:
        // i valori da considerare sono quelli relativi alla posizione
        // della lettera nel proprio insieme (cifra o carattere alfabetico)
        // La tabella infatti è 'A'=0, 'B'=1, 'C'=2... '0'=0, '1'=1, '2'=2...
        // ***
        // Allo stesso modo con i caratteri dispari che devono essere convertiti però
        // utilizzando la seconda tabella e vengono tutti sommati.
        // ***
        // DA UNA ANALISI DELLA TABELLA SI RICAVA CHE:
        // i primi dieci valori sono uguali per le prime 10 lettere e per le cifre
        // quindi posso fare riferimento ad un'unica tabella per entrambe le
        // tipologie di caratteri -> per ottenere il valore
        // da utilizzare dovrò semplicemente calcolare lo spiazzamento del carattere
        // rispetto al proprio insieme di appartenenza, cioè 0-9 o A-Z
        // ***
        int[] dispari = { 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 };
        // accumulatore per la somma progressiva
        int somma = 0;
        int sp = 0; // per calcolare lo spiazzamento per individuare il valore da sommare
        // devo ciclare su tutti i caratteri
        // perché i numeri ottenuti dalle tabelle devono essere sommati
        for (int indice = 0; indice < 15; ++indice) {
            char c = codfisc.charAt(indice);
            // calcolo lo spiazzamento rispetto all'insieme di appartenenza del carattere
            if (c >= '0' && c <= '9') // se è una cifra
                sp = c - '0'; // spiazzamento di una cifra
            else // altrimenti sarà una lettera!
                sp = c - 'A'; // spiazzamento di una lettera
            if (indice % 2 == 0)
                // sono in posizione dispari
                somma += dispari[sp]; // prendo il valore dalla tabella
            else
                // sono in posizione pari
                somma += sp; // il valore ottenuto è proprio quello da sommare
        }
        // il totale viene diviso per 26.
        // Il resto della divisione dev'essere convertito usando l'ultima tabella.
        int resto = somma % 26; // resto della divisione tra somma e 26
        // DA UNA ANALISI DELLA TABELLA SI NOTA COME IL CARATTERE FORNITO SIA DATO
        // CONSIDERANDO IL NUMERO OTTENUTO COME SE FOSSE LA POSIZIONE
        // DEL CARATTERE DA RESTITUIRE ALL'INTERNO DELL'ALFABETO
        // Il carattere corrispondente è il codice di controllo!
        return (char) (resto + 'A');
    }

    // Gestisce data di nascita e sesso
    static String letterePerData(java.util.Date data, char sesso) {
        String risultato = "";
        // CREIAMO UN CALENDARIO PER LA GESTIONE DELLA DATA
        Calendar cal = Calendar.getInstance();
        cal.setTime(data);
        // RECUPERO LE PARTI DELLA DATA
        int anno = cal.get(Calendar.YEAR); // anno a 4 cifre
        int mese = cal.get(Calendar.MONTH); // Mese da 0 a 11!
        int giorno = cal.get(Calendar.DAY_OF_MONTH); // giorno nel mese
        // Per l'anno vengono prese semplicemente le ultime due cifre.
        risultato += anno;
        risultato = risultato.substring(2);
        // Per quanto riguarda il mese c'è una tabella di conversione.
        // Ad ogni mese corrisponde una lettera dell'alfabeto: ABCDEHLMPRST
        char[] mesi = { 'A', 'B', 'C', 'D', 'E', 'H', 'L', 'M', 'P', 'R', 'S', 'T' };
        risultato += mesi[mese];
        // è sufficiente riportare il numero del giorno,
        if (sesso == 'f' || sesso == 'F')
            // con il particolare che per le donne questo numero dev'essere aumentato di 40!
            giorno += 40;
        // considero il caso in cui giorno sia inferiore a 10
        if (giorno < 10)
            // quindi aggiungo uno 0
            risultato += "0";
        // aggiungo il giorno
        risultato += giorno;
        return risultato;
    }

    // Gestisce il nome
    static String letterePerIlNome(String n) {
        String risultato = "";
        // Per il nome il discorso è analogo al cognome,
        String consonanti = dammiConsonanti(n);
        // con la particolarità che se il nome è composto da 4 o più consonanti
        if (consonanti.length() > 3)
            // vengono prese nell'ordine la prima, la terza e la quarta.
            risultato = consonanti.substring(0, 1) + consonanti.substring(2);
        else
            risultato = consonanti;
        // Anche qui potremmo trovarci nella situazione di un numero di
        // consonanti minore di 3 e allo stesso modo si aggiungo le vocali.
        if (risultato.length() < 3)
            risultato += dammiVocali(n);
        // Ripetiamo anche qui che se il nome è più corto di 3 lettere
        // è possibile sostituire i caratteri mancanti con delle X
        if (risultato.length() < 3)
            risultato += "X";

        return risultato.substring(0, 3);
    }

    // Gestisce il cognome
    static String letterePerIlCognome(String c) {
        String risultato = "";
        // Chiaramente se ci sono cognomi con più parti,
        // è necessario rimuovere gli spazi e considerare tutto come un cognome unico.
        // Sono necessari 3 caratteri per rappresentare il cognome,
        // e sono la prima la seconda e la terza consonante del cognome.
        String consonanti = dammiConsonanti(c);
        risultato = consonanti;
        // E' possibile che le consonanti siano meno di tre,
        if (risultato.length() < 3) {
            // in questo caso è possibile aggiungere le vocali nell'ordine in cui
            // compaiono nel cognome.
            String vocali = dammiVocali(c);
            risultato += vocali;
        }
        // Per cognomi più corti di 3 caratteri,
        if (risultato.length() < 3)
            // è possibile sostituire il
            // carattere mancante con la lettera X.
            risultato += "X";
        // restituisce 3 caratteri (mi mette al riparo dall'aver letto più consonanti)
        return risultato.substring(0, 3);
    }

    static String dammiConsonanti(String t) {
        // creo una variabile in cui accumulare il risultato
        String risultato = "";
        // prendo la stringa di input e la memorizzo in maiuscolo
        String testo = t.toUpperCase();
        // Scorro la stringa e prendo solo le consonanti
        // toCharArray() restituisce un array di
        // char da una stringa
        for (char c : testo.toCharArray()) { // enhanced for
//      for (int indice = 0; indice < testo.length(); ++indice) {
//          char c = testo.charAt(indice);
            // controllo che sia un carattere alfabetico (per saltare eventuali
            // spazi o apostrofi) e che non si tratti di una vocale
            if (c >= 'B' && c <= 'Z' && c != 'E' && c != 'I' && c != 'O' && c != 'U')
                risultato += c;
        }
        return risultato;
    }

    static String dammiConsonantiVocali(String t) {
        // creo una variabile in cui accumulare il risultato
        String consonanti = "";
        String vocali = "";
        // prendo la stringa di input e la memorizzo in maiuscolo
        String testo = t.toUpperCase();
        // Scorro la stringa e prendo solo le consonanti
        // toCharArray() restituisce un array di
        // char da una stringa
        for (char c : testo.toCharArray()) { // enhanced for
//      for (int indice = 0; indice < testo.length(); ++indice) {
//          char c = testo.charAt(indice);
            // controllo che sia un carattere alfabetico (per saltare eventuali
            // spazi o apostrofi) e che non si tratti di una vocale
            if (c >= 'A' && c <= 'Z')
                // se è una vocale
                if (c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U')
                    // aggiungo alle vocali
                    vocali += c;
                else
                    // altrimenti aggiungo alle consonanti
                    consonanti += c;
        }
        // concateno consonanti e vocali e restituisco il valore
        return consonanti + vocali;
    }

    static String dammiVocali(String t) {
        // creo una variabile in cui accumulare il risultato
        String risultato = "";
        // prendo la stringa di input e la memorizzo in maiuscolo
        String testo = t.toUpperCase();
        // Scorro la stringa e prendo solo le consonanti
        for (char c : testo.toCharArray())
            // controllo che si tratti di una vocale
            if (c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U')
                risultato += c;
        return risultato;
    }

    public static void main(String[] args) {
        String n = "Paperino";
        String c = "Paolino";
        Calendar d = Calendar.getInstance();
        d.set(1990, Calendar.JANUARY, 1);
        char s = 'm';
        String ci = "P000";

        String cf = calcolaCodiceFiscale(n, c, s, d.getTime(), ci);
        System.out.println(cf);
    }

}