#!/bin/bash
# Script de sauvegarde Ansible vers partage Samba via rsync
# Auteur: Script généré par Claude
# Date: $(date +%Y-%m-%d)
set -euo pipefail

# =============================================================================
# CONFIGURATION
# =============================================================================

# Configuration Ansible
ANSIBLE_HOME="/etc/ansible"
ANSIBLE_CONFIG_FILE="/etc/ansible/ansible.cfg"
ANSIBLE_INVENTORY_DIR="/etc/ansible/inventories"
ANSIBLE_PLAYBOOKS_DIR="/opt/ansible/playbooks"
ANSIBLE_ROLES_DIR="/opt/ansible/roles"
ANSIBLE_COLLECTIONS_DIR="/usr/share/ansible/collections"
ANSIBLE_VARS_DIR="/opt/ansible/group_vars"
ANSIBLE_HOST_VARS_DIR="/opt/ansible/host_vars"
ANSIBLE_VAULT_DIR="/opt/ansible/vault"
ANSIBLE_USER="ansible"
ANSIBLE_LOG_DIR="/var/log/ansible"

# Chemins alternatifs courants pour Ansible
ALT_ANSIBLE_DIR="/home/ansible"
ALT_PLAYBOOKS_DIR="/home/ansible/playbooks"
ALT_ROLES_DIR="/home/ansible/roles"
ALT_INVENTORY_DIR="/home/ansible/inventory"

# Configuration du partage Samba
SAMBA_SERVER="192.168.77.230"
SAMBA_SHARE="/srv/samba/partage/Backups"
SAMBA_USER="root" 

# Configuration SSH
SSH_KEY_PATH="$HOME/.ssh/ansible_backup_ed25519"
SSH_OPTIONS="-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR"

# Configuration de sauvegarde
BACKUP_BASE_DIR="/tmp/ansible_backup_$(date +%Y%m%d_%H%M%S)"
REMOTE_BACKUP_DIR="ansible_backups"
LOG_FILE="/var/log/ansible_backup.log"
RETENTION_DAYS=30

# Options de sauvegarde
BACKUP_PLAYBOOKS=true       # Sauvegarder les playbooks
BACKUP_ROLES=true           # Sauvegarder les rôles
BACKUP_INVENTORIES=true     # Sauvegarder les inventaires
BACKUP_COLLECTIONS=true     # Sauvegarder les collections installées
BACKUP_VAULT=true           # Sauvegarder les fichiers vault (chiffrés)
BACKUP_LOGS=true            # Sauvegarder les logs Ansible
COMPRESS_COLLECTIONS=true   # Compresser les collections pour économiser l'espace

# =============================================================================
# FONCTIONS UTILITAIRES
# =============================================================================

log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

error_exit() {
    log "ERREUR: $1"
    exit 1
}

check_root() {
    if [[ $EUID -ne 0 ]]; then
        error_exit "Ce script doit être exécuté en tant que root"
    fi
}

check_command() {
    if ! command -v "$1" &> /dev/null; then
        return 1
    fi
    return 0
}

# =============================================================================
# INSTALLATION DES DÉPENDANCES
# =============================================================================

install_dependencies() {
    log "Vérification et installation des dépendances..."
    
    # Détecter la distribution
    if [[ -f /etc/debian_version ]]; then
        DISTRO="debian"
        PKG_MANAGER="apt-get"
        PACKAGES="rsync samba-client cifs-utils openssh-client ansible jq sqlite3 gzip tar"
    elif [[ -f /etc/redhat-release ]]; then
        DISTRO="redhat"
        PKG_MANAGER="yum"
        PACKAGES="rsync cifs-utils openssh-clients ansible jq sqlite gzip tar"
    else
        error_exit "Distribution non supportée"
    fi
    
    log "Distribution détectée: $DISTRO"
    
    # Mise à jour du cache des paquets
    if [[ "$DISTRO" == "debian" ]]; then
        apt-get update -qq
    fi
    
    # Installation des paquets manquants
    for package in $PACKAGES; do
        if [[ "$DISTRO" == "debian" ]]; then
            if ! dpkg -l | grep -q "^ii  $package "; then
                log "Installation de $package..."
                apt-get install -y -qq "$package" || log "Impossible d'installer $package (peut-être optionnel)"
            else
                log "$package est déjà installé"
            fi
        elif [[ "$DISTRO" == "redhat" ]]; then
            if ! rpm -q "$package" >/dev/null 2>&1; then
                log "Installation de $package..."
                yum install -y "$package" || log "Impossible d'installer $package (peut-être optionnel)"
            else
                log "$package est déjà installé"
            fi
        fi
    done
}

# =============================================================================
# GESTION DES CERTIFICATS SSH
# =============================================================================

setup_ssh_key() {
    log "Configuration de la clé SSH ED25519..."
    
    if [[ ! -f "$SSH_KEY_PATH" ]]; then
        log "Création de la clé SSH ED25519..."
        ssh-keygen -t ed25519 -f "$SSH_KEY_PATH" -N "" -C "ansible-backup-$(hostname)"
        chmod 600 "$SSH_KEY_PATH"
        chmod 644 "${SSH_KEY_PATH}.pub"
        
        log "Clé SSH créée: $SSH_KEY_PATH"
        log "Clé publique: ${SSH_KEY_PATH}.pub"
        echo
        log "IMPORTANT: Vous devez copier cette clé publique sur le serveur distant:"
        log "=========================================="
        cat "${SSH_KEY_PATH}.pub"
        log "=========================================="
        echo
        log "Commande pour copier la clé sur le serveur distant:"
        log "ssh-copy-id -i $SSH_KEY_PATH ${SAMBA_USER}@${SAMBA_SERVER}"
        echo
        read -p "Appuyez sur Entrée une fois la clé configurée sur le serveur distant..."
    else
        log "Clé SSH existante trouvée: $SSH_KEY_PATH"
    fi
}

test_ssh_connection() {
    log "Test de la connexion SSH..."
    if ssh -i "$SSH_KEY_PATH" $SSH_OPTIONS "${SAMBA_USER}@${SAMBA_SERVER}" "echo 'Connexion SSH réussie'" 2>/dev/null; then
        log "Connexion SSH: OK"
    else
        error_exit "Impossible de se connecter via SSH. Vérifiez la configuration de la clé."
    fi
}

# =============================================================================
# DÉTECTION DE L'ENVIRONNEMENT
# =============================================================================

detect_environment() {
    log "Détection de l'environnement Ansible..."
    
    # Détection d'Ansible
    ANSIBLE_INSTALL_TYPE="none"
    if check_command ansible; then
        ANSIBLE_INSTALL_TYPE="system"
        ANSIBLE_VERSION=$(ansible --version | head -n1 | cut -d' ' -f2)
        log "Ansible détecté: installation système (version $ANSIBLE_VERSION)"
    elif check_command ansible-playbook; then
        ANSIBLE_INSTALL_TYPE="playbook-only"
        log "Ansible détecté: ansible-playbook uniquement"
    else
        log "ATTENTION: Ansible non détecté"
    fi
    
    # Détection des répertoires Ansible existants
    DETECTED_DIRS=""
    
    # Vérification des répertoires standards
    if [[ -d "$ANSIBLE_HOME" ]]; then
        DETECTED_DIRS="$DETECTED_DIRS $ANSIBLE_HOME"
        log "Répertoire Ansible standard trouvé: $ANSIBLE_HOME"
    fi
    
    if [[ -d "$ALT_ANSIBLE_DIR" ]]; then
        DETECTED_DIRS="$DETECTED_DIRS $ALT_ANSIBLE_DIR"
        log "Répertoire Ansible alternatif trouvé: $ALT_ANSIBLE_DIR"
    fi
    
    # Adaptation des chemins selon l'environnement détecté
    if [[ -f "$ALT_ANSIBLE_DIR/ansible.cfg" ]]; then
        ANSIBLE_CONFIG_FILE="$ALT_ANSIBLE_DIR/ansible.cfg"
        log "Configuration Ansible trouvée: $ANSIBLE_CONFIG_FILE"
    fi
    
    if [[ -d "$ALT_PLAYBOOKS_DIR" ]]; then
        ANSIBLE_PLAYBOOKS_DIR="$ALT_PLAYBOOKS_DIR"
        log "Répertoire playbooks trouvé: $ANSIBLE_PLAYBOOKS_DIR"
    fi
    
    if [[ -d "$ALT_ROLES_DIR" ]]; then
        ANSIBLE_ROLES_DIR="$ALT_ROLES_DIR"
        log "Répertoire rôles trouvé: $ANSIBLE_ROLES_DIR"
    fi
    
    if [[ -d "$ALT_INVENTORY_DIR" ]]; then
        ANSIBLE_INVENTORY_DIR="$ALT_INVENTORY_DIR"
        log "Répertoire inventaire trouvé: $ANSIBLE_INVENTORY_DIR"
    fi
    
    # Détection de la configuration active
    if check_command ansible-config; then
        log "Analyse de la configuration Ansible..."
        ACTIVE_CONFIG=$(ansible-config dump 2>/dev/null | grep -E "(DEFAULT_ROLES_PATH|DEFAULT_HOST_LIST|DEFAULT_LOG_PATH)" || true)
        if [[ -n "$ACTIVE_CONFIG" ]]; then
            echo "$ACTIVE_CONFIG" > /tmp/ansible_active_config.txt
            log "Configuration active sauvegardée"
        fi
    fi
}

# =============================================================================
# FONCTIONS DE SAUVEGARDE
# =============================================================================

create_backup_structure() {
    log "Création de la structure de sauvegarde: $BACKUP_BASE_DIR"
    mkdir -p "$BACKUP_BASE_DIR"/{playbooks,roles,inventories,collections,config,vault,logs,metadata}
}

backup_playbooks() {
    log "Sauvegarde des playbooks Ansible..."
    
    if [[ "$BACKUP_PLAYBOOKS" == "true" && -d "$ANSIBLE_PLAYBOOKS_DIR" ]]; then
        log "Sauvegarde du répertoire playbooks: $ANSIBLE_PLAYBOOKS_DIR"
        rsync -av --progress "$ANSIBLE_PLAYBOOKS_DIR/" "$BACKUP_BASE_DIR/playbooks/" \
            --exclude="*.log" --exclude=".git" --exclude="__pycache__" --exclude="*.pyc"
        
        # Création d'un index des playbooks
        find "$ANSIBLE_PLAYBOOKS_DIR" -name "*.yml" -o -name "*.yaml" | \
            sed "s|^$ANSIBLE_PLAYBOOKS_DIR/||" > "$BACKUP_BASE_DIR/metadata/playbooks_index.txt"
    else
        log "Aucun répertoire playbooks trouvé ou sauvegarde désactivée"
    fi
    
    # Recherche de playbooks dans d'autres emplacements courants
    for dir in "/opt/ansible" "/home/ansible" "$HOME/ansible" "/usr/local/ansible"; do
        if [[ -d "$dir/playbooks" && "$dir/playbooks" != "$ANSIBLE_PLAYBOOKS_DIR" ]]; then
            log "Sauvegarde de playbooks additionnels: $dir/playbooks"
            mkdir -p "$BACKUP_BASE_DIR/playbooks/additional/$(basename "$dir")"
            rsync -av --progress "$dir/playbooks/" "$BACKUP_BASE_DIR/playbooks/additional/$(basename "$dir")/" \
                --exclude="*.log" --exclude=".git" --exclude="__pycache__"
        fi
    done
}

backup_roles() {
    log "Sauvegarde des rôles Ansible..."
    
    if [[ "$BACKUP_ROLES" == "true" && -d "$ANSIBLE_ROLES_DIR" ]]; then
        log "Sauvegarde du répertoire rôles: $ANSIBLE_ROLES_DIR"
        rsync -av --progress "$ANSIBLE_ROLES_DIR/" "$BACKUP_BASE_DIR/roles/" \
            --exclude="*.log" --exclude=".git" --exclude="__pycache__" --exclude="*.pyc"
        
        # Création d'un index des rôles avec leur structure
        find "$ANSIBLE_ROLES_DIR" -name "main.yml" -o -name "main.yaml" | \
            while read -r role_main; do
                role_name=$(echo "$role_main" | sed "s|$ANSIBLE_ROLES_DIR/||" | cut -d'/' -f1)
                role_type=$(echo "$role_main" | cut -d'/' -f-2 | tail -c +$((${#ANSIBLE_ROLES_DIR}+2)))
                echo "$role_name: $role_type"
            done > "$BACKUP_BASE_DIR/metadata/roles_structure.txt" 2>/dev/null || true
    else
        log "Aucun répertoire rôles trouvé ou sauvegarde désactivée"
    fi
    
    # Sauvegarde des rôles système si disponibles
    SYSTEM_ROLES_DIR="/usr/share/ansible/roles"
    if [[ -d "$SYSTEM_ROLES_DIR" && "$SYSTEM_ROLES_DIR" != "$ANSIBLE_ROLES_DIR" ]]; then
        log "Sauvegarde des rôles système: $SYSTEM_ROLES_DIR"
        rsync -av --progress "$SYSTEM_ROLES_DIR/" "$BACKUP_BASE_DIR/roles/system/" \
            --exclude="*.log" --exclude=".git"
    fi
}

backup_inventories() {
    log "Sauvegarde des inventaires Ansible..."
    
    if [[ "$BACKUP_INVENTORIES" == "true" ]]; then
        # Inventaire principal
        if [[ -d "$ANSIBLE_INVENTORY_DIR" ]]; then
            log "Sauvegarde du répertoire inventaire: $ANSIBLE_INVENTORY_DIR"
            rsync -av --progress "$ANSIBLE_INVENTORY_DIR/" "$BACKUP_BASE_DIR/inventories/" \
                --exclude="*.log" --exclude=".git"
        fi
        
        # Fichiers d'inventaire courants
        for inv_file in "/etc/ansible/hosts" "/etc/ansible/inventory" "$HOME/ansible/inventory" \
                       "$ALT_ANSIBLE_DIR/hosts" "$ALT_ANSIBLE_DIR/inventory"; do
            if [[ -f "$inv_file" ]]; then
                log "Sauvegarde du fichier inventaire: $inv_file"
                cp "$inv_file" "$BACKUP_BASE_DIR/inventories/$(basename "$inv_file")_$(date +%Y%m%d)"
            fi
        done
        
        # Variables de groupe et d'hôte
        if [[ -d "$ANSIBLE_VARS_DIR" ]]; then
            log "Sauvegarde des variables de groupe..."
            rsync -av --progress "$ANSIBLE_VARS_DIR/" "$BACKUP_BASE_DIR/inventories/group_vars/"
        fi
        
        if [[ -d "$ANSIBLE_HOST_VARS_DIR" ]]; then
            log "Sauvegarde des variables d'hôte..."
            rsync -av --progress "$ANSIBLE_HOST_VARS_DIR/" "$BACKUP_BASE_DIR/inventories/host_vars/"
        fi
    else
        log "Sauvegarde des inventaires désactivée"
    fi
}

backup_collections() {
    log "Sauvegarde des collections Ansible..."
    
    if [[ "$BACKUP_COLLECTIONS" == "true" ]]; then
        # Collections système
        if [[ -d "$ANSIBLE_COLLECTIONS_DIR" ]]; then
            log "Sauvegarde des collections système: $ANSIBLE_COLLECTIONS_DIR"
            if [[ "$COMPRESS_COLLECTIONS" == "true" ]]; then
                log "Compression des collections en cours..."
                tar -czf "$BACKUP_BASE_DIR/collections/system_collections.tar.gz" \
                    -C "$(dirname "$ANSIBLE_COLLECTIONS_DIR")" "$(basename "$ANSIBLE_COLLECTIONS_DIR")"
            else
                rsync -av --progress "$ANSIBLE_COLLECTIONS_DIR/" "$BACKUP_BASE_DIR/collections/system/"
            fi
        fi
        
        # Collections utilisateur
        USER_COLLECTIONS_DIR="$HOME/.ansible/collections"
        if [[ -d "$USER_COLLECTIONS_DIR" ]]; then
            log "Sauvegarde des collections utilisateur: $USER_COLLECTIONS_DIR"
            if [[ "$COMPRESS_COLLECTIONS" == "true" ]]; then
                tar -czf "$BACKUP_BASE_DIR/collections/user_collections.tar.gz" \
                    -C "$HOME/.ansible" "collections"
            else
                rsync -av --progress "$USER_COLLECTIONS_DIR/" "$BACKUP_BASE_DIR/collections/user/"
            fi
        fi
        
        # Liste des collections installées
        if check_command ansible-galaxy; then
            log "Création de la liste des collections installées..."
            ansible-galaxy collection list > "$BACKUP_BASE_DIR/metadata/installed_collections.txt" 2>/dev/null || true
        fi
    else
        log "Sauvegarde des collections désactivée"
    fi
}

backup_configuration() {
    log "Sauvegarde de la configuration Ansible..."
    
    # Fichier de configuration principal
    if [[ -f "$ANSIBLE_CONFIG_FILE" ]]; then
        log "Sauvegarde du fichier de configuration: $ANSIBLE_CONFIG_FILE"
        cp "$ANSIBLE_CONFIG_FILE" "$BACKUP_BASE_DIR/config/ansible.cfg"
    fi
    
    # Configuration active (dump)
    if [[ -f /tmp/ansible_active_config.txt ]]; then
        cp /tmp/ansible_active_config.txt "$BACKUP_BASE_DIR/config/active_config.txt"
        rm -f /tmp/ansible_active_config.txt
    fi
    
    # Variables d'environnement Ansible
    env | grep -E '^ANSIBLE_' > "$BACKUP_BASE_DIR/config/ansible_env_vars.txt" || true
    
    # Configuration SSH si utilisée par Ansible
    if [[ -f "$HOME/.ssh/config" ]]; then
        log "Sauvegarde de la configuration SSH..."
        cp "$HOME/.ssh/config" "$BACKUP_BASE_DIR/config/ssh_config"
    fi
    
    # Clés SSH utilisées par Ansible (sans les clés privées)
    if [[ -d "$HOME/.ssh" ]]; then
        find "$HOME/.ssh" -name "*.pub" -exec cp {} "$BACKUP_BASE_DIR/config/" \; 2>/dev/null || true
    fi
}

backup_vault() {
    log "Sauvegarde des fichiers vault Ansible..."
    
    if [[ "$BACKUP_VAULT" == "true" && -d "$ANSIBLE_VAULT_DIR" ]]; then
        log "Sauvegarde du répertoire vault: $ANSIBLE_VAULT_DIR"
        rsync -av --progress "$ANSIBLE_VAULT_DIR/" "$BACKUP_BASE_DIR/vault/"
    fi
    
    # Recherche de fichiers vault dans les playbooks et rôles
    if [[ "$BACKUP_VAULT" == "true" ]]; then
        log "Recherche de fichiers vault dans l'arborescence..."
        
        # Construction de la liste des répertoires à rechercher
        SEARCH_DIRS=""
        [[ -d "$ANSIBLE_PLAYBOOKS_DIR" ]] && SEARCH_DIRS="$SEARCH_DIRS $ANSIBLE_PLAYBOOKS_DIR"
        [[ -d "$ANSIBLE_ROLES_DIR" ]] && SEARCH_DIRS="$SEARCH_DIRS $ANSIBLE_ROLES_DIR"
        
        if [[ -n "$SEARCH_DIRS" ]]; then
            find $SEARCH_DIRS -name "*vault*" -type f 2>/dev/null | \
                while read -r vault_file; do
                    if [[ -f "$vault_file" ]]; then
                        # Déterminer le chemin relatif correct
                        rel_path=""
                        if [[ "$vault_file" == "$ANSIBLE_PLAYBOOKS_DIR"* ]]; then
                            rel_path="playbooks/$(echo "$vault_file" | sed "s|$ANSIBLE_PLAYBOOKS_DIR/||")"
                        elif [[ "$vault_file" == "$ANSIBLE_ROLES_DIR"* ]]; then
                            rel_path="roles/$(echo "$vault_file" | sed "s|$ANSIBLE_ROLES_DIR/||")"
                        else
                            rel_path="other/$(basename "$vault_file")"
                        fi
                        
                        mkdir -p "$BACKUP_BASE_DIR/vault/discovered/$(dirname "$rel_path")"
                        cp "$vault_file" "$BACKUP_BASE_DIR/vault/discovered/$rel_path" 2>/dev/null || true
                    fi
                done
        else
            log "Aucun répertoire de playbooks ou rôles trouvé pour la recherche de vault"
        fi
    fi
}

backup_logs() {
    log "Sauvegarde des logs Ansible..."
    
    if [[ "$BACKUP_LOGS" == "true" && -d "$ANSIBLE_LOG_DIR" ]]; then
        log "Sauvegarde du répertoire de logs: $ANSIBLE_LOG_DIR"
        rsync -av --progress "$ANSIBLE_LOG_DIR/" "$BACKUP_BASE_DIR/logs/" \
            --exclude="*.tmp" --include="*.log" --include="*.log.*"
    fi
    
    # Logs système d'Ansible
    if [[ -f "/var/log/ansible.log" ]]; then
        cp "/var/log/ansible.log" "$BACKUP_BASE_DIR/logs/system_ansible.log"
    fi
    
    # Journaux systemd si disponibles
    if check_command journalctl; then
        log "Export des journaux systemd pour Ansible..."
        journalctl -u ansible* --no-pager > "$BACKUP_BASE_DIR/logs/systemd_ansible.log" 2>/dev/null || true
    fi
}

create_metadata() {
    log "Création des métadonnées de sauvegarde..."
    
    # Informations système
    cat > "$BACKUP_BASE_DIR/metadata/system_info.txt" << EOF
Sauvegarde Ansible
==================
Date: $(date)
Serveur: $(hostname)
Version script: 1.0
Utilisateur: $(whoami)
Type d'installation Ansible: $ANSIBLE_INSTALL_TYPE
Répertoires sauvegardés:
- Configuration: $ANSIBLE_CONFIG_FILE
- Playbooks: $ANSIBLE_PLAYBOOKS_DIR
- Rôles: $ANSIBLE_ROLES_DIR
- Inventaires: $ANSIBLE_INVENTORY_DIR
- Collections: $ANSIBLE_COLLECTIONS_DIR
- Logs: $ANSIBLE_LOG_DIR
Options de sauvegarde:
- Playbooks: $BACKUP_PLAYBOOKS
- Rôles: $BACKUP_ROLES
- Inventaires: $BACKUP_INVENTORIES
- Collections: $BACKUP_COLLECTIONS
- Vault: $BACKUP_VAULT
- Logs: $BACKUP_LOGS
- Compression collections: $COMPRESS_COLLECTIONS
EOF
    
    # Version d'Ansible
    if check_command ansible; then
        echo "" >> "$BACKUP_BASE_DIR/metadata/system_info.txt"
        echo "Informations Ansible:" >> "$BACKUP_BASE_DIR/metadata/system_info.txt"
        ansible --version >> "$BACKUP_BASE_DIR/metadata/system_info.txt" 2>/dev/null || true
    fi
    
    # Liste des modules disponibles
    if check_command ansible-doc; then
        log "Création de la liste des modules disponibles..."
        ansible-doc -l > "$BACKUP_BASE_DIR/metadata/available_modules.txt" 2>/dev/null || true
    fi
    
    # Taille de la sauvegarde
    BACKUP_SIZE=$(du -sh "$BACKUP_BASE_DIR" | cut -f1)
    echo "Taille totale de la sauvegarde: $BACKUP_SIZE" >> "$BACKUP_BASE_DIR/metadata/system_info.txt"
    
    log "Sauvegarde locale créée dans: $BACKUP_BASE_DIR (Taille: $BACKUP_SIZE)"
}

sync_to_remote() {
    log "Synchronisation vers le serveur distant..."
    
    # Création du répertoire distant si nécessaire
    ssh -i "$SSH_KEY_PATH" $SSH_OPTIONS "${SAMBA_USER}@${SAMBA_SERVER}" \
        "mkdir -p ${SAMBA_SHARE}/${REMOTE_BACKUP_DIR}/$(date +%Y/%m)"
    
    # Synchronisation des fichiers
    REMOTE_PATH="${SAMBA_USER}@${SAMBA_SERVER}:${SAMBA_SHARE}/${REMOTE_BACKUP_DIR}/$(date +%Y/%m)/ansible_backup_$(date +%Y%m%d_%H%M%S)/"
    
    log "Envoi vers: $REMOTE_PATH"
    rsync -avz --progress --delete \
          -e "ssh -i $SSH_KEY_PATH $SSH_OPTIONS" \
          "$BACKUP_BASE_DIR/" \
          "$REMOTE_PATH"
    
    log "Synchronisation terminée"
}

cleanup_local() {
    log "Nettoyage des fichiers temporaires..."
    if [[ -d "$BACKUP_BASE_DIR" ]]; then
        rm -rf "$BACKUP_BASE_DIR"
        log "Répertoire temporaire supprimé: $BACKUP_BASE_DIR"
    fi
}

cleanup_remote() {
    log "Nettoyage des anciennes sauvegardes (plus de $RETENTION_DAYS jours)..."
    
    ssh -i "$SSH_KEY_PATH" $SSH_OPTIONS "${SAMBA_USER}@${SAMBA_SERVER}" \
        "find ${SAMBA_SHARE}/${REMOTE_BACKUP_DIR} -type d -name 'ansible_backup_*' -mtime +${RETENTION_DAYS} -exec rm -rf {} + 2>/dev/null || true"
    
    log "Nettoyage des anciennes sauvegardes terminé"
}

# =============================================================================
# FONCTION PRINCIPALE
# =============================================================================

main() {
    log "=== DÉBUT DE LA SAUVEGARDE ANSIBLE ==="
    
    # Vérifications préliminaires
    check_root
    
    # Installation des dépendances
    install_dependencies
    
    # Configuration SSH
    setup_ssh_key
    test_ssh_connection
    
    # Détection de l'environnement
    detect_environment
    
    # Gestion des erreurs avec nettoyage
    trap 'cleanup_local' EXIT ERR
    
    # Création de la structure de sauvegarde
    create_backup_structure
    
    # Sauvegarde des playbooks
    backup_playbooks
    
    # Sauvegarde des rôles
    backup_roles
    
    # Sauvegarde des inventaires
    backup_inventories
    
    # Sauvegarde des collections
    backup_collections
    
    # Sauvegarde de la configuration
    backup_configuration
    
    # Sauvegarde des fichiers vault
    backup_vault
    
    # Sauvegarde des logs
    backup_logs
    
    # Création des métadonnées
    create_metadata
    
    # Synchronisation vers le serveur distant
    sync_to_remote
    
    # Nettoyage
    cleanup_remote
    cleanup_local
    
    log "=== SAUVEGARDE ANSIBLE TERMINÉE AVEC SUCCÈS ==="
}

# =============================================================================
# POINT D'ENTRÉE
# =============================================================================

# Vérification des arguments pour les options avancées
while [[ $# -gt 0 ]]; do
    case $1 in
        --no-playbooks)
            BACKUP_PLAYBOOKS=false
            log "Option: Sauvegarde des playbooks désactivée"
            shift
            ;;
        --no-roles)
            BACKUP_ROLES=false
            log "Option: Sauvegarde des rôles désactivée"
            shift
            ;;
        --no-collections)
            BACKUP_COLLECTIONS=false
            log "Option: Sauvegarde des collections désactivée"
            shift
            ;;
        --no-vault)
            BACKUP_VAULT=false
            log "Option: Sauvegarde des fichiers vault désactivée"
            shift
            ;;
        --no-logs)
            BACKUP_LOGS=false
            log "Option: Sauvegarde des logs désactivée"
            shift
            ;;
        --no-compression)
            COMPRESS_COLLECTIONS=false
            log "Option: Compression des collections désactivée"
            shift
            ;;
        --help)
            echo "Usage: $0 [OPTIONS]"
            echo "Options:"
            echo "  --no-playbooks    Ne pas sauvegarder les playbooks Ansible"
            echo "  --no-roles        Ne pas sauvegarder les rôles Ansible"
            echo "  --no-collections  Ne pas sauvegarder les collections"
            echo "  --no-vault        Ne pas sauvegarder les fichiers vault"
            echo "  --no-logs         Ne pas sauvegarder les logs"
            echo "  --no-compression  Ne pas compresser les collections"
            echo "  --help           Afficher cette aide"
            exit 0
            ;;
        *)
            error_exit "Option inconnue: $1"
            ;;
    esac
done

# Création du fichier de log si nécessaire
mkdir -p "$(dirname "$LOG_FILE")"
touch "$LOG_FILE"

# Lancement du script principal
main "$@"