Cod Fis Par IVA Validation

package main

import (
    "fmt"
    "regexp"
    "strconv"
    "strings"
)

// IsValidCodiceFiscale verifica la validità formale e del carattere di controllo
// di un codice fiscale italiano.
// Gestisce anche i caratteri numerici dell'omocodia.
func IsValidCodiceFiscale(cf string) bool {
    cf = strings.ToUpper(strings.TrimSpace(cf))

    // Il codice fiscale deve contenere esattamente 16 caratteri
    if len(cf) != 16 {
        return false
    }

    // Formato: 6 lettere + 2 cifre + 1 lettera + 2 cifre + 1 lettera + 3 cifre + 1 lettera
    // Sono ammessi i caratteri dell'omocodia nelle posizioni numeriche.
    matched, _ := regexp.MatchString(
        `^[A-Z]{6}[A-Z0-9]{2}[A-Z][A-Z0-9]{2}[A-Z][A-Z0-9]{3}[A-Z]$`,
        cf,
    )

    if !matched {
        return false
    }

    // Tabella caratteri dispari
    oddValues := map[byte]int{
        '0': 1, '1': 0, '2': 5, '3': 7, '4': 9,
        '5': 13, '6': 15, '7': 17, '8': 19, '9': 21,
        'A': 1, 'B': 0, 'C': 5, 'D': 7, 'E': 9,
        'F': 13, 'G': 15, 'H': 17, 'I': 19, 'J': 21,
        'K': 2, 'L': 4, 'M': 18, 'N': 20, 'O': 11,
        'P': 3, 'Q': 6, 'R': 8, 'S': 12, 'T': 14,
        'U': 16, 'V': 10, 'W': 22, 'X': 25, 'Y': 24,
        'Z': 23,
    }

    // Tabella caratteri pari
    evenValues := map[byte]int{
        '0': 0, '1': 1, '2': 2, '3': 3, '4': 4,
        '5': 5, '6': 6, '7': 7, '8': 8, '9': 9,
        'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4,
        'F': 5, 'G': 6, 'H': 7, 'I': 8, 'J': 9,
        'K': 10, 'L': 11, 'M': 12, 'N': 13, 'O': 14,
        'P': 15, 'Q': 16, 'R': 17, 'S': 18, 'T': 19,
        'U': 20, 'V': 21, 'W': 22, 'X': 23, 'Y': 24,
        'Z': 25,
    }

    sum := 0

    // Le posizioni sono numerate da 1 a 15
    for i := 0; i < 15; i++ {
        if (i+1)%2 == 1 {
            sum += oddValues[cf[i]]
        } else {
            sum += evenValues[cf[i]]
        }
    }

    expectedControl := byte('A' + (sum % 26))

    return cf[15] == expectedControl
}

// IsValidPartitaIVA verifica la validità formale e del checksum
// di una Partita IVA italiana.
func IsValidPartitaIVA(piva string) bool {
    piva = strings.TrimSpace(piva)

    // Rimuove eventualmente il prefisso internazionale
    piva = strings.ToUpper(piva)
    piva = strings.TrimPrefix(piva, "IT")

    // Deve contenere esattamente 11 cifre
    if len(piva) != 11 {
        return false
    }

    for _, c := range piva {
        if c < '0' || c > '9' {
            return false
        }
    }

    // Algoritmo ufficiale del carattere di controllo:
    // posizione dispari: valore invariato
    // posizione pari: valore * 2, somma delle cifre se > 9
    sum := 0

    for i := 0; i < 10; i++ {
        n, _ := strconv.Atoi(string(piva[i]))

        // Posizioni numerate da 1 a 10
        if (i+1)%2 == 0 {
            n *= 2
            if n > 9 {
                n = (n / 10) + (n % 10)
            }
        }

        sum += n
    }

    checkDigit := (10 - (sum % 10)) % 10

    lastDigit, _ := strconv.Atoi(string(piva[10]))

    return checkDigit == lastDigit
}

func main() {
    fmt.Println(IsValidCodiceFiscale("RSSMRA80A01H501U"))
    // true

    fmt.Println(IsValidCodiceFiscale("RSSMRA80A01H501X"))
    // false

    fmt.Println(IsValidPartitaIVA("01093321006"))
    // true

    fmt.Println(IsValidPartitaIVA("01093321007"))
}