#!/usr/bin/env python3
"""
Modulo per la cancellazione sicura di file tramite sovrascrittura multipla.
Utilizzabile come script standalone o importabile in altri progetti.

Come usarlo a riga di comando 

# Cancella un singolo file
python secure_delete.py documento.txt

# Cancella più file con 5 passate
python secure_delete.py -p 5 file1.dat file2.dat

# Modalità silenziosa (nessun output)
python secure_delete.py -q segreto.bin

Come usarlo come modulo in altro script

from secure_delete import secure_delete

# Cancella "originale.pdf" con impostazioni predefinite
secure_delete("originale.pdf")

# Cancella con 7 passate e senza messaggi
secure_delete("dati.dat", passes=7, verbose=False)

"""

import os
import sys
import argparse

# Fallback per generazione numeri casuali crittograficamente sicuri
try:
    from secrets import token_bytes
    def secure_random_bytes(n):
        return token_bytes(n)
except ImportError:
    def secure_random_bytes(n):
        return os.urandom(n)


def secure_delete(filepath, passes=3, verbose=True):
    """
    Sovrascrive un file più volte con pattern casuali e fissi prima di eliminarlo.

    Attenzione:
    - Su SSD, unità flash e file system con journaling o copy-on-write,
      questa funzione NON garantisce la cancellazione fisica definitiva.
    - Per dati estremamente sensibili su SSD, usare comandi ATA SECURITY ERASE
      o crittografia full-disk a monte.

    Args:
        filepath (str): Percorso del file da eliminare.
        passes (int): Numero di passate di sovrascrittura (default 3).
        verbose (bool): Stampa messaggi di stato.

    Returns:
        bool: True se la cancellazione è riuscita, False altrimenti.
    """
    if not os.path.exists(filepath):
        if verbose:
            print(f"⚠️  Il file '{filepath}' non esiste.")
        return False

    try:
        size = os.path.getsize(filepath)
        if size == 0:
            os.remove(filepath)
            if verbose:
                print(f"✓ File vuoto '{filepath}' rimosso.")
            return True

        # Pattern di sovrascrittura ciclici
        patterns = [
            lambda: secure_random_bytes(size),  # Casuale crittografico
            lambda: b'\x00' * size,             # Zeri
            lambda: b'\xFF' * size              # Uno
        ]

        # Apertura con flag O_SYNC per ridurre buffer del sistema operativo
        fd = os.open(filepath, os.O_WRONLY | os.O_SYNC)
        try:
            for i in range(passes):
                pattern = patterns[i % len(patterns)]()
                os.write(fd, pattern)
                os.fsync(fd)  # Forza flush su disco
                if verbose:
                    print(f"  Passata {i+1}/{passes} completata")
        finally:
            os.close(fd)

        # Tronca a lunghezza zero e rimuove
        with open(filepath, 'wb') as f:
            f.truncate(0)
        os.remove(filepath)

        if verbose:
            print(f"✓ File '{filepath}' sovrascritto e rimosso.")
        return True

    except Exception as e:
        if verbose:
            print(f"✗ ERRORE durante la cancellazione: {e}")
        return False


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description="Cancellazione sicura di file tramite sovrascrittura multipla.",
        epilog="ATTENZIONE: su SSD o file system moderni la cancellazione fisica non è garantita."
    )
    parser.add_argument('file', nargs='+', help='File da eliminare in modo sicuro')
    parser.add_argument('-p', '--passes', type=int, default=3,
                        help='Numero di passate di sovrascrittura (default: 3)')
    parser.add_argument('-q', '--quiet', action='store_true',
                        help='Non stampare messaggi di avanzamento')

    args = parser.parse_args()

    success = True
    for f in args.file:
        if not secure_delete(f, passes=args.passes, verbose=not args.quiet):
            success = False

    sys.exit(0 if success else 1)