#!/bin/bash

# Script de sauvegarde et restauration des comptes et partages réseau GNOME
# Auteur: Fontaine Johnny
# Version: 1.1 - Ajout sauvegarde SSH

# Couleurs pour l'affichage
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Répertoires et fichiers
BACKUP_DIR="$HOME/Backups/gnome-accounts-network-backup"
GOA_CONFIG_DIR="$HOME/.config/goa-1.0"
EVOLUTION_CONFIG_DIR="$HOME/.config/evolution"
KEYRING_DIR="$HOME/.local/share/keyrings"
NETWORK_CONFIG_DIR="/etc/NetworkManager/system-connections"
USER_NETWORK_CONFIG_DIR="$HOME/.config/NetworkManager"
SSH_CONFIG_DIR="$HOME/.ssh"

# Fonction d'affichage avec couleurs
print_info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

print_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

print_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $1"
}

print_error() {
    echo -e "${RED}[ERROR]${NC} $1"
}

# Fonction pour installer les prérequis manquants
install_requirements() {
    print_info "Installation automatique des prérequis manquants..."

    local packages_to_install=()

    # Vérifier dconf
    if ! command -v dconf &> /dev/null; then
        print_info "dconf manquant - ajout à la liste d'installation"
        packages_to_install+=("dconf-cli")
    fi

    # Vérifier secret-tool
    if ! command -v secret-tool &> /dev/null; then
        print_info "secret-tool manquant - ajout à la liste d'installation"
        packages_to_install+=("libsecret-tools")
    fi

    # Vérifier seahorse (gestionnaire de trousseau graphique)
    if ! command -v seahorse &> /dev/null; then
        print_info "seahorse manquant - ajout à la liste d'installation"
        packages_to_install+=("seahorse")
    fi

    # Installer les paquets manquants
    if [ ${#packages_to_install[@]} -gt 0 ]; then
        print_info "Installation des paquets: ${packages_to_install[*]}"

        # Détecter le gestionnaire de paquets
        if command -v apt &> /dev/null; then
            sudo apt update && sudo apt install -y "${packages_to_install[@]}"
        elif command -v dnf &> /dev/null; then
            sudo dnf install -y "${packages_to_install[@]}"
        elif command -v yum &> /dev/null; then
            sudo yum install -y "${packages_to_install[@]}"
        elif command -v pacman &> /dev/null; then
            sudo pacman -S --noconfirm "${packages_to_install[@]}"
        elif command -v zypper &> /dev/null; then
            sudo zypper install -y "${packages_to_install[@]}"
        else
            print_error "Gestionnaire de paquets non supporté. Installez manuellement: ${packages_to_install[*]}"
            exit 1
        fi

        if [ $? -eq 0 ]; then
            print_success "Prérequis installés avec succès"
        else
            print_error "Erreur lors de l'installation des prérequis"
            exit 1
        fi
    else
        print_success "Tous les prérequis sont déjà installés"
    fi
}

# Fonction pour vérifier les prérequis
check_requirements() {
    print_info "Vérification des prérequis..."

    # Vérifier si GNOME est en cours d'exécution
    if ! pgrep -x "gnome-shell" > /dev/null; then
        print_warning "GNOME Shell ne semble pas être en cours d'exécution"
    fi

    # Installer automatiquement les prérequis manquants
    install_requirements

    print_success "Prérequis vérifiés et installés"
}

# Fonction de sauvegarde
backup_accounts_network() {
    print_info "Début de la sauvegarde des comptes et partages réseau GNOME..."

    # Créer le répertoire de sauvegarde
    mkdir -p "$BACKUP_DIR"

    # Date de la sauvegarde
    BACKUP_DATE=$(date +"%Y%m%d_%H%M%S")
    BACKUP_BASE="$BACKUP_DIR/gnome-accounts-network-$BACKUP_DATE"

    # Créer un répertoire pour cette sauvegarde
    mkdir -p "$BACKUP_BASE"

    # Sauvegarder GNOME Online Accounts (GOA)
    print_info "Sauvegarde des comptes en ligne (GNOME Online Accounts)..."
    if [ -d "$GOA_CONFIG_DIR" ]; then
        cp -r "$GOA_CONFIG_DIR" "$BACKUP_BASE/goa-1.0" 2>/dev/null
        if [ $? -eq 0 ]; then
            print_success "Comptes en ligne sauvegardés"
        else
            print_warning "Erreur lors de la sauvegarde des comptes en ligne"
        fi
    else
        print_warning "Répertoire GOA non trouvé: $GOA_CONFIG_DIR"
    fi

    # Sauvegarder Evolution (comptes mail)
    print_info "Sauvegarde des comptes Evolution (mail)..."
    if [ -d "$EVOLUTION_CONFIG_DIR" ]; then
        # Sauvegarder seulement les sources de données et la configuration
        mkdir -p "$BACKUP_BASE/evolution"
        if [ -d "$EVOLUTION_CONFIG_DIR/sources" ]; then
            cp -r "$EVOLUTION_CONFIG_DIR/sources" "$BACKUP_BASE/evolution/" 2>/dev/null
        fi
        if [ -f "$EVOLUTION_CONFIG_DIR/evolution.conf" ]; then
            cp "$EVOLUTION_CONFIG_DIR/evolution.conf" "$BACKUP_BASE/evolution/" 2>/dev/null
        fi
        # Copier les fichiers de configuration des comptes
        find "$EVOLUTION_CONFIG_DIR" -name "*.source" -o -name "*.conf" | while read -r file; do
            rel_path=$(realpath --relative-to="$EVOLUTION_CONFIG_DIR" "$file" 2>/dev/null || echo "$file")
            mkdir -p "$BACKUP_BASE/evolution/$(dirname "$rel_path")"
            cp "$file" "$BACKUP_BASE/evolution/$rel_path" 2>/dev/null
        done
        print_success "Configuration Evolution sauvegardée"
    else
        print_warning "Répertoire Evolution non trouvé: $EVOLUTION_CONFIG_DIR"
    fi

    # Sauvegarder la configuration SSH
    print_info "Sauvegarde de la configuration SSH..."
    if [ -d "$SSH_CONFIG_DIR" ]; then
        SSH_BACKUP="$BACKUP_BASE/ssh"
        mkdir -p "$SSH_BACKUP"

        print_warning "ATTENTION: Sauvegarde des clés SSH privées!"
        print_warning "Cette opération sauvegarde vos clés privées SSH (TRÈS SENSIBLE!)"

        # Sauvegarder tous les fichiers SSH
        cp -r "$SSH_CONFIG_DIR"/* "$SSH_BACKUP/" 2>/dev/null

        # Créer un inventaire des fichiers SSH sauvegardés
        SSH_INVENTORY="$SSH_BACKUP/ssh-inventory.txt"
        {
            echo "=== INVENTAIRE DES FICHIERS SSH SAUVEGARDÉS ==="
            echo "Date: $(date)"
            echo "Utilisateur: $USER"
            echo ""
            echo "Fichiers sauvegardés:"
            ls -la "$SSH_BACKUP/" 2>/dev/null | grep -v "ssh-inventory.txt"
            echo ""
            echo "⚠  ATTENTION: Clés privées sauvegardées!"
            echo "⚠  Ne partagez JAMAIS ces fichiers!"
            echo ""

            # Lister les clés publiques avec leurs empreintes
            if command -v ssh-keygen &> /dev/null; then
                echo "=== EMPREINTES DES CLÉS PUBLIQUES ==="
                find "$SSH_BACKUP" -name "*.pub" | while read -r pubkey; do
                    if [ -f "$pubkey" ]; then
                        keyname=$(basename "$pubkey")
                        echo "Clé: $keyname"
                        ssh-keygen -lf "$pubkey" 2>/dev/null || echo "  Erreur lecture empreinte"
                        echo ""
                    fi
                done
            fi

            # Analyser le fichier config s'il existe
            if [ -f "$SSH_BACKUP/config" ]; then
                echo "=== CONFIGURATION SSH (config) ==="
                echo "Hosts configurés:"
                grep -E "^Host " "$SSH_BACKUP/config" 2>/dev/null | sed 's/Host /  - /' || echo "  Aucun host configuré"
                echo ""
            fi
        } > "$SSH_INVENTORY"

        # Sécuriser les permissions des clés privées sauvegardées
        find "$SSH_BACKUP" -type f -name "*" ! -name "*.pub" ! -name "config" ! -name "known_hosts*" ! -name "ssh-inventory.txt" -exec chmod 600 {} \; 2>/dev/null
        find "$SSH_BACKUP" -name "*.pub" -exec chmod 644 {} \; 2>/dev/null
        [ -f "$SSH_BACKUP/config" ] && chmod 600 "$SSH_BACKUP/config"

        print_success "Configuration SSH sauvegardée"
        print_warning "Inventaire créé: $SSH_INVENTORY"

        # Compter les éléments sauvegardés
        ssh_files_count=$(ls -1 "$SSH_BACKUP/" 2>/dev/null | wc -l)
        private_keys_count=$(find "$SSH_BACKUP" -type f -name "*" ! -name "*.pub" ! -name "config" ! -name "known_hosts*" ! -name "ssh-inventory.txt" | wc -l)
        public_keys_count=$(find "$SSH_BACKUP" -name "*.pub" | wc -l)

        print_info "SSH sauvegardé: $ssh_files_count fichiers ($private_keys_count clés privées, $public_keys_count clés publiques)"
    else
        print_warning "Répertoire SSH non trouvé: $SSH_CONFIG_DIR"
    fi

    # Sauvegarder les paramètres dconf liés aux comptes
    print_info "Sauvegarde des paramètres des comptes (dconf)..."
    DCONF_ACCOUNTS="$BACKUP_BASE/accounts-settings.dconf"
    {
        dconf dump /org/gnome/online-accounts/
        dconf dump /org/gnome/evolution-data-server/
        dconf dump /org/gnome/evolution/
        dconf dump /org/gnome/settings-daemon/plugins/sharing/
    } > "$DCONF_ACCOUNTS" 2>/dev/null

    if [ -s "$DCONF_ACCOUNTS" ]; then
        print_success "Paramètres des comptes sauvegardés"
    else
        print_warning "Aucun paramètre de compte à sauvegarder"
    fi

    # Sauvegarder les connexions réseau (avec sudo si nécessaire)
    print_info "Sauvegarde des connexions réseau..."
    NETWORK_BACKUP="$BACKUP_BASE/network-connections"
    mkdir -p "$NETWORK_BACKUP"

    # Connexions système (nécessite sudo)
    if [ -d "$NETWORK_CONFIG_DIR" ] && sudo -n true 2>/dev/null; then
        print_info "Sauvegarde des connexions système (avec sudo)..."
        sudo cp -r "$NETWORK_CONFIG_DIR"/* "$NETWORK_BACKUP/" 2>/dev/null
        if [ $? -eq 0 ]; then
            sudo chown -R "$USER:$USER" "$NETWORK_BACKUP"
            print_success "Connexions système sauvegardées"
        fi
    else
        print_warning "Impossible de sauvegarder les connexions système (sudo requis ou non disponible)"
    fi

    # Connexions utilisateur
    if [ -d "$USER_NETWORK_CONFIG_DIR" ]; then
        cp -r "$USER_NETWORK_CONFIG_DIR" "$BACKUP_BASE/user-network-config" 2>/dev/null
        print_success "Configuration réseau utilisateur sauvegardée"
    fi

    # Sauvegarder les partages réseau (dconf)
    print_info "Sauvegarde des paramètres de partage réseau..."
    DCONF_SHARING="$BACKUP_BASE/sharing-settings.dconf"
    {
        dconf dump /org/gnome/settings-daemon/plugins/sharing/
        dconf dump /org/gnome/desktop/file-sharing/
        dconf dump /org/gtk/settings/file-chooser/
    } > "$DCONF_SHARING" 2>/dev/null

    if [ -s "$DCONF_SHARING" ]; then
        print_success "Paramètres de partage sauvegardés"
    else
        print_warning "Aucun paramètre de partage à sauvegarder"
    fi

    # Sauvegarder la liste des signets de fichiers (lieux réseau)
    print_info "Sauvegarde des signets de fichiers..."
    BOOKMARKS_FILE="$HOME/.config/gtk-3.0/bookmarks"
    if [ -f "$BOOKMARKS_FILE" ]; then
        cp "$BOOKMARKS_FILE" "$BACKUP_BASE/gtk-bookmarks" 2>/dev/null
        print_success "Signets de fichiers sauvegardés"
    else
        print_warning "Fichier de signets non trouvé"
    fi

    # Sauvegarder le trousseau de clés COMPLET (ATTENTION: SENSIBLE!)
    print_warning "ATTENTION: Sauvegarde des mots de passe du trousseau de clés..."
    print_warning "Cette opération sauvegarde les mots de passe en texte quasi-lisible!"
    print_warning "Protégez absolument ces fichiers de sauvegarde!"

    KEYRING_BACKUP="$BACKUP_BASE/keyring-passwords"
    mkdir -p "$KEYRING_BACKUP"

    # Sauvegarder les trousseaux de clés physiques
    if [ -d "$KEYRING_DIR" ]; then
        print_info "Sauvegarde des fichiers de trousseau de clés..."
        cp -r "$KEYRING_DIR" "$BACKUP_BASE/keyring-files" 2>/dev/null
        if [ $? -eq 0 ]; then
            print_success "Fichiers de trousseau copiés"
        else
            print_warning "Erreur lors de la copie des fichiers de trousseau"
        fi
    fi

    # Exporter les secrets avec secret-tool (si disponible)
    if command -v secret-tool &> /dev/null; then
        print_info "Export des mots de passe avec secret-tool..."

        # Créer un script d'export des secrets
        SECRETS_EXPORT="$KEYRING_BACKUP/secrets-export.txt"
        SECRETS_RESTORE="$KEYRING_BACKUP/restore-secrets.sh"

        {
            echo "=== SECRETS EXPORTÉS (ATTENTION: SENSIBLE!) ==="
            echo "Date: $(date)"
            echo "Utilisateur: $USER"
            echo ""
        } > "$SECRETS_EXPORT"

        {
            echo "#!/bin/bash"
            echo "# Script de restauration des secrets"
            echo "# ATTENTION: Ce fichier contient des mots de passe!"
            echo ""
        } > "$SECRETS_RESTORE"
        chmod +x "$SECRETS_RESTORE"

        # Sauvegarder tous les WiFi avec leurs mots de passe
        print_info "Sauvegarde des mots de passe WiFi..."
        WIFI_PASSWORDS="$KEYRING_BACKUP/wifi-passwords.txt"
        {
            echo "=== MOTS DE PASSE WIFI ==="
            echo "Date: $(date)"
            echo ""
        } > "$WIFI_PASSWORDS"

        # Lister toutes les connexions WiFi et extraire les mots de passe
        if command -v nmcli &> /dev/null; then
            nmcli -g NAME,TYPE connection show | grep ":802-11-wireless" | cut -d: -f1 | while read -r wifi_name; do
                if [ -n "$wifi_name" ]; then
                    password=$(nmcli -g 802-11-wireless-security.psk connection show "$wifi_name" 2>/dev/null)
                    if [ -n "$password" ] && [ "$password" != "--" ]; then
                        echo "WiFi: $wifi_name" >> "$WIFI_PASSWORDS"
                        echo "Mot de passe: $password" >> "$WIFI_PASSWORDS"
                        echo "" >> "$WIFI_PASSWORDS"

                        # Ajouter au script de restauration
                        echo "# Restauration WiFi: $wifi_name" >> "$SECRETS_RESTORE"
                        echo "nmcli connection modify \"$wifi_name\" 802-11-wireless-security.psk \"$password\" 2>/dev/null || true" >> "$SECRETS_RESTORE"
                    fi
                fi
            done
        fi

        # Exporter les comptes en ligne avec tentative de récupération des tokens
        print_info "Tentative d'export des tokens des comptes en ligne..."
        GOA_SECRETS="$KEYRING_BACKUP/goa-secrets.txt"
        {
            echo "=== SECRETS DES COMPTES EN LIGNE ==="
            echo "Date: $(date)"
            echo ""
        } > "$GOA_SECRETS"

        if [ -d "$GOA_CONFIG_DIR" ]; then
            find "$GOA_CONFIG_DIR" -name "*.conf" | while read -r account_file; do
                if [ -f "$account_file" ]; then
                    provider=$(grep "Provider=" "$account_file" 2>/dev/null | cut -d'=' -f2)
                    identity=$(grep "Identity=" "$account_file" 2>/dev/null | cut -d'=' -f2)
                    account_id=$(basename "$account_file" .conf)

                    if [ -n "$provider" ] && [ -n "$identity" ]; then
                        echo "Compte: $provider - $identity" >> "$GOA_SECRETS"
                        echo "ID: $account_id" >> "$GOA_SECRETS"

                        # Chercher les secrets associés
                        secret-tool search goa-identity "$identity" 2>/dev/null | while read -r line; do
                            if [[ "$line" == "secret = "* ]]; then
                                secret_value=$(echo "$line" | sed 's/^secret = //')
                                echo "Secret: $secret_value" >> "$GOA_SECRETS"
                            fi
                        done || true
                        echo "" >> "$GOA_SECRETS"
                    fi
                fi
            done
        fi

        if [ -s "$SECRETS_EXPORT" ] || [ -s "$WIFI_PASSWORDS" ] || [ -s "$GOA_SECRETS" ]; then
            print_success "Mots de passe sauvegardés"
            print_warning "FICHIERS SENSIBLES créés dans $KEYRING_BACKUP"
        else
            print_warning "Aucun mot de passe récupéré automatiquement"
        fi
    fi

    # Créer une archive compressée
    print_info "Création de l'archive compressée..."
    ARCHIVE_FILE="$BACKUP_DIR/gnome-accounts-network-$BACKUP_DATE.tar.gz"
    tar -czf "$ARCHIVE_FILE" -C "$BACKUP_DIR" "gnome-accounts-network-$BACKUP_DATE" 2>/dev/null
    if [ $? -eq 0 ]; then
        rm -rf "$BACKUP_BASE"  # Supprimer le répertoire temporaire
        print_success "Archive créée: $ARCHIVE_FILE"
    else
        print_error "Erreur lors de la création de l'archive"
    fi

    # Créer un fichier de métadonnées
    METADATA_FILE="$BACKUP_DIR/backup-metadata-$BACKUP_DATE.txt"
    {
        echo "=== SAUVEGARDE COMPTES ET RÉSEAU GNOME ==="
        echo "Date: $(date)"
        echo "Utilisateur: $USER"
        echo "Version GNOME: $(gnome-shell --version 2>/dev/null || echo 'Non disponible')"
        echo "Système: $(lsb_release -d 2>/dev/null | cut -f2 || uname -a)"
        echo "NetworkManager: $(nmcli --version 2>/dev/null | head -n1 || echo 'Non disponible')"
        echo ""
        echo "Éléments sauvegardés:"
        echo "- Comptes en ligne GNOME (GOA)"
        echo "- Configuration Evolution (mail)"
        echo "- Configuration SSH (clés et config)"
        echo "- Paramètres des comptes"
        echo "- Connexions réseau"
        echo "- Paramètres de partage"
        echo "- Signets de fichiers"
        echo "- MOTS DE PASSE (trousseau de clés)"
        echo "- Mots de passe WiFi"
        echo ""
        echo "⚠  ATTENTION: Clés SSH privées incluses!"
        echo "⚠  ATTENTION: Fichiers de mots de passe inclus!"
        echo "⚠  Protégez absolument cette sauvegarde!"
        echo "Archive: $(basename "$ARCHIVE_FILE")"
    } > "$METADATA_FILE"

    print_success "Sauvegarde terminée! Fichiers dans: $BACKUP_DIR"
    print_info "Métadonnées sauvegardées dans: $METADATA_FILE"
}

# Fonction de restauration
restore_accounts_network() {
    print_info "Restauration des comptes et partages réseau GNOME..."

    # Lister les sauvegardes disponibles
    if [ ! -d "$BACKUP_DIR" ] || [ -z "$(ls -A "$BACKUP_DIR"/*.tar.gz 2>/dev/null)" ]; then
        print_error "Aucune sauvegarde trouvée dans $BACKUP_DIR"
        return
    fi

    echo "Sauvegardes disponibles:"
    select backup_file in "$BACKUP_DIR"/*.tar.gz; do
        if [ -n "$backup_file" ]; then
            break
        else
            print_error "Sélection invalide"
        fi
    done

    # Extraire la date de la sauvegarde sélectionnée
    BACKUP_DATE=$(basename "$backup_file" | sed 's/gnome-accounts-network-\(.*\)\.tar\.gz/\1/')

    print_info "Restauration depuis: $(basename "$backup_file")"

    # Demander confirmation
    echo ""
    print_warning "ATTENTION: Cette opération va :"
    print_warning "- Remplacer vos comptes et paramètres actuels"
    print_warning "- Restaurer les mots de passe sauvegardés"
    print_warning "- Restaurer la configuration SSH (clés privées incluses!)"
    print_warning "- Il est recommandé de fermer Evolution et autres applications"
    echo ""
    read -p "Voulez-vous continuer avec la restauration? (y/N): " confirm
    if [[ ! "$confirm" =~ ^[Yy]$ ]]; then
        print_info "Restauration annulée"
        return
    fi

    # Créer un répertoire temporaire pour l'extraction
    TEMP_DIR=$(mktemp -d)
    print_info "Extraction de l'archive..."
    tar -xzf "$backup_file" -C "$TEMP_DIR" 2>/dev/null
    if [ $? -ne 0 ]; then
        print_error "Erreur lors de l'extraction de l'archive"
        rm -rf "$TEMP_DIR"
        return
    fi

    RESTORE_DIR="$TEMP_DIR/gnome-accounts-network-$BACKUP_DATE"

    # Créer une sauvegarde de sécurité
    print_info "Création d'une sauvegarde de sécurité..."
    SAFETY_DATE=$(date +"%Y%m%d_%H%M%S")
    SAFETY_BACKUP="$BACKUP_DIR/safety-backup-$SAFETY_DATE"
    mkdir -p "$SAFETY_BACKUP"

    [ -d "$GOA_CONFIG_DIR" ] && cp -r "$GOA_CONFIG_DIR" "$SAFETY_BACKUP/goa-1.0-backup" 2>/dev/null
    [ -d "$EVOLUTION_CONFIG_DIR" ] && cp -r "$EVOLUTION_CONFIG_DIR" "$SAFETY_BACKUP/evolution-backup" 2>/dev/null
    [ -d "$SSH_CONFIG_DIR" ] && cp -r "$SSH_CONFIG_DIR" "$SAFETY_BACKUP/ssh-backup" 2>/dev/null
    print_success "Sauvegarde de sécurité créée: $SAFETY_BACKUP"

    # Restaurer GNOME Online Accounts
    if [ -d "$RESTORE_DIR/goa-1.0" ]; then
        print_info "Restauration des comptes en ligne..."
        mkdir -p "$HOME/.config"
        rm -rf "$GOA_CONFIG_DIR" 2>/dev/null
        cp -r "$RESTORE_DIR/goa-1.0" "$GOA_CONFIG_DIR" 2>/dev/null
        print_success "Comptes en ligne restaurés"
    fi

    # Restaurer Evolution
    if [ -d "$RESTORE_DIR/evolution" ]; then
        print_info "Restauration de la configuration Evolution..."
        mkdir -p "$EVOLUTION_CONFIG_DIR"
        cp -r "$RESTORE_DIR/evolution"/* "$EVOLUTION_CONFIG_DIR/" 2>/dev/null
        print_success "Configuration Evolution restaurée"
    fi

    # Restaurer la configuration SSH
    if [ -d "$RESTORE_DIR/ssh" ]; then
        print_warning "ATTENTION: Restauration de la configuration SSH avec clés privées!"
        read -p "Restaurer la configuration SSH (clés privées incluses)? (y/N): " restore_ssh
        if [[ "$restore_ssh" =~ ^[Yy]$ ]]; then
            print_info "Restauration de la configuration SSH..."

            # Créer le répertoire SSH s'il n'existe pas
            mkdir -p "$SSH_CONFIG_DIR"
            chmod 700 "$SSH_CONFIG_DIR"

            # Copier tous les fichiers SSH
            cp -r "$RESTORE_DIR/ssh"/* "$SSH_CONFIG_DIR/" 2>/dev/null

            # Restaurer les permissions correctes
            chmod 700 "$SSH_CONFIG_DIR"
            find "$SSH_CONFIG_DIR" -type f -name "*" ! -name "*.pub" ! -name "config" ! -name "known_hosts*" ! -name "ssh-inventory.txt" -exec chmod 600 {} \; 2>/dev/null
            find "$SSH_CONFIG_DIR" -name "*.pub" -exec chmod 644 {} \; 2>/dev/null
            [ -f "$SSH_CONFIG_DIR/config" ] && chmod 600 "$SSH_CONFIG_DIR/config"
            [ -f "$SSH_CONFIG_DIR/known_hosts" ] && chmod 644 "$SSH_CONFIG_DIR/known_hosts"

            # Supprimer le fichier d'inventaire s'il a été copié
            [ -f "$SSH_CONFIG_DIR/ssh-inventory.txt" ] && rm -f "$SSH_CONFIG_DIR/ssh-inventory.txt"

            print_success "Configuration SSH restaurée"

            # Afficher les clés restaurées
            if command -v ssh-keygen &> /dev/null; then
                print_info "Clés publiques restaurées:"
                find "$SSH_CONFIG_DIR" -name "*.pub" | while read -r pubkey; do
                    if [ -f "$pubkey" ]; then
                        keyname=$(basename "$pubkey")
                        echo "  - $keyname"
                        ssh-keygen -lf "$pubkey" 2>/dev/null | sed 's/^/    /'
                    fi
                done
            fi

            # Démarrer ssh-agent si pas déjà fait et ajouter les clés
            if command -v ssh-add &> /dev/null; then
                print_info "Tentative d'ajout des clés à l'agent SSH..."
                if [ -z "$SSH_AUTH_SOCK" ]; then
                    eval $(ssh-agent -s) 2>/dev/null
                fi

                # Ajouter toutes les clés privées trouvées
                find "$SSH_CONFIG_DIR" -type f -name "*" ! -name "*.pub" ! -name "config" ! -name "known_hosts*" | while read -r private_key; do
                    if [ -f "$private_key" ]; then
                        ssh-add "$private_key" 2>/dev/null && echo "  Clé ajoutée: $(basename "$private_key")" || true
                    fi
                done
            fi
        else
            print_info "Restauration SSH ignorée"
        fi
    fi

    # Restaurer les paramètres des comptes
    if [ -f "$RESTORE_DIR/accounts-settings.dconf" ] && [ -s "$RESTORE_DIR/accounts-settings.dconf" ]; then
        print_info "Restauration des paramètres des comptes..."
        dconf load / < "$RESTORE_DIR/accounts-settings.dconf" 2>/dev/null
        print_success "Paramètres des comptes restaurés"
    fi

    # Restaurer les connexions réseau
    if [ -d "$RESTORE_DIR/network-connections" ]; then
        print_info "Restauration des connexions réseau..."
        if sudo -n true 2>/dev/null; then
            sudo cp -r "$RESTORE_DIR/network-connections"/* "$NETWORK_CONFIG_DIR/" 2>/dev/null
            sudo systemctl reload NetworkManager 2>/dev/null
            print_success "Connexions réseau restaurées"
        else
            print_warning "Sudo requis pour restaurer les connexions système - ignoré"
        fi
    fi

    # Restaurer la configuration réseau utilisateur
    if [ -d "$RESTORE_DIR/user-network-config" ]; then
        print_info "Restauration de la configuration réseau utilisateur..."
        mkdir -p "$HOME/.config"
        cp -r "$RESTORE_DIR/user-network-config" "$USER_NETWORK_CONFIG_DIR" 2>/dev/null
        print_success "Configuration réseau utilisateur restaurée"
    fi

    # Restaurer les paramètres de partage
    if [ -f "$RESTORE_DIR/sharing-settings.dconf" ] && [ -s "$RESTORE_DIR/sharing-settings.dconf" ]; then
        print_info "Restauration des paramètres de partage..."
        dconf load / < "$RESTORE_DIR/sharing-settings.dconf" 2>/dev/null
        print_success "Paramètres de partage restaurés"
    fi

    # Restaurer les trousseaux de clés et mots de passe
    if [ -d "$RESTORE_DIR/keyring-files" ]; then
        print_warning "ATTENTION: Restauration des trousseaux de clés avec mots de passe!"
        read -p "Restaurer les mots de passe sauvegardés? (y/N): " restore_passwords
        if [[ "$restore_passwords" =~ ^[Yy]$ ]]; then
            print_info "Restauration des fichiers de trousseau..."

            # Sauvegarder les trousseaux actuels
            [ -d "$KEYRING_DIR" ] && cp -r "$KEYRING_DIR" "$SAFETY_BACKUP/keyring-backup" 2>/dev/null

            # Restaurer les trousseaux
            mkdir -p "$HOME/.local/share"
            rm -rf "$KEYRING_DIR" 2>/dev/null
            cp -r "$RESTORE_DIR/keyring-files/keyrings" "$KEYRING_DIR" 2>/dev/null

            print_success "Trousseaux de clés restaurés"

            # Restaurer les mots de passe WiFi
            if [ -f "$RESTORE_DIR/keyring-passwords/restore-secrets.sh" ]; then
                print_info "Exécution du script de restauration des secrets..."
                bash "$RESTORE_DIR/keyring-passwords/restore-secrets.sh" 2>/dev/null
                print_success "Script de restauration exécuté"
            fi

            # Redémarrer le démon gnome-keyring si possible
            if pgrep -x "gnome-keyring-daemon" > /dev/null; then
                print_info "Redémarrage du démon gnome-keyring..."
                pkill -f gnome-keyring-daemon 2>/dev/null
                sleep 2
                gnome-keyring-daemon --start --components=secrets,ssh,gpg 2>/dev/null &
                print_success "Démon gnome-keyring redémarré"
            fi
        else
            print_info "Restauration des mots de passe ignorée"
        fi
    fi

    # Restaurer les signets
    if [ -f "$RESTORE_DIR/gtk-bookmarks" ]; then
        print_info "Restauration des signets de fichiers..."
        mkdir -p "$HOME/.config/gtk-3.0"
        cp "$RESTORE_DIR/gtk-bookmarks" "$HOME/.config/gtk-3.0/bookmarks" 2>/dev/null
        print_success "Signets de fichiers restaurés"
    fi

    # Nettoyer
    rm -rf "$TEMP_DIR"

    print_success "Restauration terminée!"
    print_warning "Actions recommandées :"
    print_warning "1. Redémarrez votre session complètement (déconnexion/reconnexion)"
    print_warning "2. Vérifiez vos comptes dans Paramètres > Comptes en ligne"
    print_warning "3. Testez vos connexions WiFi"
    print_warning "4. Testez vos connexions SSH (ssh-add -l pour voir les clés chargées)"
    print_warning "5. Relancez Evolution si vous l'utilisez"
    print_warning "6. Si les mots de passe ne fonctionnent pas, vérifiez les fichiers dans keyring-passwords/"
    print_warning "7. Vérifiez les permissions de vos clés SSH (~/.ssh/)"
}

# Fonction pour lister les sauvegardes
list_backups() {
    print_info "Sauvegardes disponibles:"

    if [ ! -d "$BACKUP_DIR" ]; then
        print_warning "Répertoire de sauvegarde non trouvé: $BACKUP_DIR"
        return
    fi

    for backup in "$BACKUP_DIR"/gnome-accounts-network-*.tar.gz; do
        if [ -f "$backup" ]; then
            filename=$(basename "$backup")
            date_part=$(echo "$filename" | sed 's/gnome-accounts-network-\(.*\)\.tar\.gz/\1/')
            readable_date=$(echo "$date_part" | sed 's/\([0-9]\{4\}\)\([0-9]\{2\}\)\([0-9]\{2\}\)_\([0-9]\{2\}\)\([0-9]\{2\}\)\([0-9]\{2\}\)/\3\/\2\/\1 \4:\5:\6/')
            size=$(du -h "$backup" | cut -f1)
            echo "  - $filename (Taille: $size, Date: $readable_date)"

            # Vérifier les fichiers associés
            metadata_file="$BACKUP_DIR/backup-metadata-$date_part.txt"
            if [ -f "$metadata_file" ]; then
                echo "    └── Métadonnées disponibles"
            fi
        fi
    done

    if [ -z "$(ls -A "$BACKUP_DIR"/gnome-accounts-network-*.tar.gz 2>/dev/null)" ]; then
        print_warning "Aucune sauvegarde trouvée"
    fi
}

# Fonction pour nettoyer les anciennes sauvegardes
cleanup_backups() {
    print_info "Nettoyage des anciennes sauvegardes..."

    if [ ! -d "$BACKUP_DIR" ]; then
        print_warning "Répertoire de sauvegarde non trouvé"
        return
    fi

    read -p "Combien de sauvegardes souhaitez-vous conserver? (défaut: 3): " keep_count
    keep_count=${keep_count:-3}

    # Supprimer les anciennes sauvegardes (garder les plus récentes)
    ls -t "$BACKUP_DIR"/gnome-accounts-network-*.tar.gz 2>/dev/null | tail -n +$((keep_count + 1)) | while read -r old_backup; do
        if [ -f "$old_backup" ]; then
            date_part=$(basename "$old_backup" | sed 's/gnome-accounts-network-\(.*\)\.tar\.gz/\1/')
            print_info "Suppression de $(basename "$old_backup")"
            rm -f "$old_backup"
            rm -f "$BACKUP_DIR/backup-metadata-$date_part.txt"
            rm -rf "$BACKUP_DIR/safety-backup-"* 2>/dev/null
        fi
    done

    print_success "Nettoyage terminé"
}

# Fonction pour afficher les informations sur les comptes actuels
show_accounts_info() {
    print_info "Informations sur les comptes et connexions actuels:"
    echo ""

    # Comptes en ligne GNOME
    if [ -d "$GOA_CONFIG_DIR" ]; then
        echo "📧 Comptes en ligne GNOME:"
        find "$GOA_CONFIG_DIR" -name "*.conf" | while read -r account_file; do
            if [ -f "$account_file" ]; then
                provider=$(grep "Provider=" "$account_file" 2>/dev/null | cut -d'=' -f2)
                identity=$(grep "Identity=" "$account_file" 2>/dev/null | cut -d'=' -f2)
                [ -n "$provider" ] && echo "  - $provider: $identity"
            fi
        done
        echo ""
    fi

    # Configuration SSH
    if [ -d "$SSH_CONFIG_DIR" ]; then
        echo "🔐 Configuration SSH:"

        # Lister les clés SSH
        echo "  Clés SSH disponibles:"
        find "$SSH_CONFIG_DIR" -name "*.pub" | while read -r pubkey; do
            if [ -f "$pubkey" ]; then
                keyname=$(basename "$pubkey" .pub)
                echo "    - $keyname"
                if command -v ssh-keygen &> /dev/null; then
                    fingerprint=$(ssh-keygen -lf "$pubkey" 2>/dev/null | awk '{print $2}')
                    [ -n "$fingerprint" ] && echo "      Empreinte: $fingerprint"
                fi
            fi
        done

        # Analyser le fichier config SSH
        if [ -f "$SSH_CONFIG_DIR/config" ]; then
            echo "  Hosts configurés dans ~/.ssh/config:"
            grep -E "^Host " "$SSH_CONFIG_DIR/config" 2>/dev/null | sed 's/Host /    - /' || echo "    Aucun host configuré"
        fi

        # Clés chargées dans l'agent SSH
        if command -v ssh-add &> /dev/null && [ -n "$SSH_AUTH_SOCK" ]; then
            echo "  Clés chargées dans l'agent SSH:"
            ssh_keys_loaded=$(ssh-add -l 2>/dev/null)
            if [ $? -eq 0 ]; then
                echo "$ssh_keys_loaded" | sed 's/^/    /'
            else
                echo "    Aucune clé chargée ou agent SSH non disponible"
            fi
        fi
        echo ""
    fi

    # Connexions réseau
    if command -v nmcli &> /dev/null; then
        echo "🌐 Connexions réseau configurées:"
        nmcli connection show 2>/dev/null | tail -n +2 | while read -r line; do
            name=$(echo "$line" | awk '{print $1}')
            type=$(echo "$line" | awk '{print $3}')
            [ -n "$name" ] && echo "  - $name ($type)"
        done
        echo ""
    fi

    # Signets de fichiers
    if [ -f "$HOME/.config/gtk-3.0/bookmarks" ]; then
        echo "📁 Signets de fichiers/réseau:"
        grep -E "(smb://|ftp://|sftp://)" "$HOME/.config/gtk-3.0/bookmarks" 2>/dev/null | while read -r bookmark; do
            url=$(echo "$bookmark" | awk '{print $1}')
            name=$(echo "$bookmark" | cut -d' ' -f2-)
            [ -n "$url" ] && echo "  - $name ($url)"
        done
        echo ""
    fi
}

# Fonction d'aide
show_help() {
    echo "Script de sauvegarde et restauration des comptes et partages réseau GNOME"
    echo ""
    echo "Ce script sauvegarde et restaure :"
    echo "  • Comptes en ligne GNOME (Google, Microsoft, Nextcloud, etc.)"
    echo "  • Configuration Evolution (comptes mail)"
    echo "  • Configuration SSH (clés privées, clés publiques, fichier config)"
    echo "  • Connexions réseau WiFi/Ethernet"
    echo "  • Paramètres de partage réseau"
    echo "  • Signets de fichiers réseau"
    echo ""
    echo "Usage: $0 [OPTION]"
    echo ""
    echo "Options:"
    echo "  backup, -b     Sauvegarder les comptes et réseau"
    echo "  restore, -r    Restaurer les comptes et réseau"
    echo "  list, -l       Lister les sauvegardes disponibles"
    echo "  cleanup, -c    Nettoyer les anciennes sauvegardes"
    echo "  info, -i       Afficher les comptes/connexions actuels"
    echo "  help, -h       Afficher cette aide"
    echo ""
    echo "IMPORTANT:"
    echo "  ⚠  Les mots de passe SONT sauvegardés (non sécurisé)"
    echo "  ⚠  Les clés SSH privées SONT sauvegardées (TRÈS sensible!)"
    echo "  ⚠  Protégez absolument vos fichiers de sauvegarde"
    echo "  ⚠  Ne partagez jamais ces sauvegardes"
    echo "  • Sudo peut être requis pour les connexions système"
    echo ""
    echo "Répertoire de sauvegarde: $BACKUP_DIR"
}

# Fonction pour afficher le menu principal
show_menu() {
    echo ""
    echo "=========================================================="
    echo "  Script de gestion des comptes, réseau et SSH GNOME"
    echo "=========================================================="
    echo ""
    echo "Choisissez une action:"
    echo "1) Sauvegarder les comptes, réseau et SSH"
    echo "2) Restaurer les comptes, réseau et SSH"
    echo "3) Lister les sauvegardes"
    echo "4) Nettoyer les anciennes sauvegardes"
    echo "5) Afficher les comptes/connexions actuels"
    echo "6) Afficher l'aide"
    echo "7) Quitter"
    echo ""
}

# Fonction pour demander de continuer
ask_continue() {
    echo ""
    echo "=========================================================="
    read -p "Appuyez sur Entrée pour revenir au menu principal..."
    echo ""
}

# Boucle principale interactive
interactive_menu() {
    while true; do
        show_menu
        read -p "Votre choix (1-7): " choice

        case $choice in
            1) 
                check_requirements && backup_accounts_network
                ask_continue
                ;;
            2) 
                check_requirements && restore_accounts_network
                ask_continue
                ;;
            3) 
                list_backups
                ask_continue
                ;;
            4) 
                cleanup_backups
                ask_continue
                ;;
            5) 
                show_accounts_info
                ask_continue
                ;;
            6) 
                show_help
                ask_continue
                ;;
            7) 
                print_info "Au revoir!"
                exit 0
                ;;
            *) 
                print_error "Choix invalide"
                sleep 1
                ;;
        esac
    done
}

# Programme principal
main() {
    case "${1:-}" in
        backup|-b)
            check_requirements
            backup_accounts_network
            ;;
        restore|-r)
            check_requirements
            restore_accounts_network
            ;;
        list|-l)
            list_backups
            ;;
        cleanup|-c)
            cleanup_backups
            ;;
        info|-i)
            show_accounts_info
            ;;
        help|-h|--help)
            show_help
            ;;
        *)
            # Mode interactif par défaut
            interactive_menu
            ;;
    esac
}

main "$@"