#!/bin/bash
#
# Migration de la base de données Magento 2.4.7
# Ce script permet d'importer une base de données Magento depuis une sauvegarde ou un serveur source
#

# Vérification que le script est exécuté en tant que root
if [ "$(id -u)" -ne 0 ]; then
   echo "Ce script doit être exécuté en tant que root" 
   exit 1
fi

# Chargement de la configuration
if [ -f "./00_config.sh" ]; then
    source ./00_config.sh
else
    echo "Fichier de configuration 00_config.sh non trouvé. Veuillez le créer."
    exit 1
fi

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

# Fonction pour afficher un message de statut
status_message() {
    local status=$1
    local message=$2
    
    if [ "$status" = "OK" ]; then
        echo -e "[${GREEN}OK${NC}] $message"
    elif [ "$status" = "WARNING" ]; then
        echo -e "[${YELLOW}WARNING${NC}] $message"
    elif [ "$status" = "ERROR" ]; then
        echo -e "[${RED}ERROR${NC}] $message"
    elif [ "$status" = "INFO" ]; then
        echo -e "[${BLUE}INFO${NC}] $message"
    else
        echo "$message"
    fi
}

# Fonction d'aide
show_help() {
    echo "Usage: $0 [options]"
    echo ""
    echo "Options:"
    echo "  -h, --help                  Afficher cette aide"
    echo "  -f, --file FICHIER          Importer depuis un fichier SQL ou SQL compressé"
    echo "  -s, --source-host HÔTE      Hôte du serveur MySQL source (défaut: $SOURCE_HOST)"
    echo "  -u, --source-user USER      Utilisateur MySQL source (défaut: $SOURCE_USER)"
    echo "  -p, --source-pass PASS      Mot de passe MySQL source"
    echo "  -d, --source-db DB          Base de données source (défaut: $SOURCE_DATABASE)"
    echo "  -t, --target-db DB          Base de données cible (défaut: $DEST_DATABASE)"
    echo "  --no-data                   Importer uniquement la structure (sans données)"
    echo "  --only-tables TABLES        Importer uniquement les tables spécifiées (séparées par des virgules)"
    echo "  --exclude-tables TABLES     Exclure les tables spécifiées (séparées par des virgules) (défaut: $EXCLUDE_TABLES)"
    echo "  --old-domain DOMAIN         Ancien domaine à remplacer (défaut: $OLD_DOMAIN)"
    echo "  --new-domain DOMAIN         Nouveau domaine (défaut: $NEW_DOMAIN)"
    echo "  --skip-domain-replace       Ne pas remplacer les domaines"
    echo ""
    echo "Exemples:"
    echo "  $0                          Utilise les paramètres du fichier de configuration"
    echo "  $0 -f /chemin/vers/sauvegarde.sql"
    echo "  $0 -s $SOURCE_HOST -u $SOURCE_USER -p [PASSWORD] -d $SOURCE_DATABASE"
    echo "  $0 --skip-domain-replace    Migration sans remplacement de domaine"
    echo ""
}

# Initialisation des variables depuis la configuration
SOURCE_FILE=""
SOURCE_HOST_ARG="$SOURCE_HOST"
SOURCE_USER_ARG="$SOURCE_USER"
SOURCE_PASS_ARG="$SOURCE_PASSWORD"
SOURCE_DB_ARG="$SOURCE_DATABASE"
TARGET_DB_ARG="$DEST_DATABASE"
EXCLUDE_TABLES_ARG="$EXCLUDE_TABLES"
OLD_DOMAIN_ARG="$OLD_DOMAIN"
NEW_DOMAIN_ARG="$NEW_DOMAIN"
NO_DATA=false
ONLY_TABLES=""
SKIP_DOMAIN_REPLACE=false
# Traitement des arguments
while [[ $# -gt 0 ]]; do
    key="$1"
    case $key in
        -h|--help)
            show_help
            exit 0
            ;;
        -f|--file)
            SOURCE_FILE="$2"
            shift
            shift
            ;;
        -s|--source-host)
            SOURCE_HOST_ARG="$2"
            shift
            shift
            ;;
        -u|--source-user)
            SOURCE_USER_ARG="$2"
            shift
            shift
            ;;
        -p|--source-pass)
            SOURCE_PASS_ARG="$2"
            shift
            shift
            ;;
        -d|--source-db)
            SOURCE_DB_ARG="$2"
            shift
            shift
            ;;
        -t|--target-db)
            TARGET_DB_ARG="$2"
            shift
            shift
            ;;
        --no-data)
            NO_DATA=true
            shift
            ;;
        --only-tables)
            ONLY_TABLES="$2"
            shift
            shift
            ;;
        --exclude-tables)
            EXCLUDE_TABLES_ARG="$2"
            shift
            shift
            ;;
        --old-domain)
            OLD_DOMAIN_ARG="$2"
            shift
            shift
            ;;
        --new-domain)
            NEW_DOMAIN_ARG="$2"
            shift
            shift
            ;;
        --skip-domain-replace)
            SKIP_DOMAIN_REPLACE=true
            shift
            ;;
        *)
            echo "Option inconnue: $1"
            show_help
            exit 1
            ;;
    esac
done

# Vérification des paramètres et préparation de la migration
status_message "INFO" "Préparation de la migration de base de données..."

# Vérification de la base de données cible
DB_EXISTS=0
if mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "USE $TARGET_DB_ARG" 2>/dev/null; then
    DB_EXISTS=1
    # Vérifier si la base contient des tables
    TABLE_COUNT=$(mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "SELECT COUNT(TABLE_NAME) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='$TARGET_DB_ARG';" | tail -n 1)
    
    if [ "$TABLE_COUNT" -gt 0 ]; then
        status_message "WARNING" "La base de données '$TARGET_DB_ARG' existe déjà et contient $TABLE_COUNT tables."
        read -p "Voulez-vous supprimer toutes les tables existantes avant l'importation ? (o/n): " CONFIRM
        
        if [[ $CONFIRM =~ ^[Oo]$ ]]; then
            status_message "INFO" "Suppression de la base de données '$TARGET_DB_ARG'..."
            mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "DROP DATABASE $TARGET_DB_ARG;"
            DB_EXISTS=0
        else
            status_message "ERROR" "Migration annulée par l'utilisateur."
            exit 1
        fi
    else
        status_message "INFO" "La base de données '$TARGET_DB_ARG' existe mais est vide."
    fi
fi

# Création de la base de données cible si elle n'existe pas
if [ "$DB_EXISTS" -eq 0 ]; then
    status_message "INFO" "Création de la base de données cible '$TARGET_DB_ARG'..."
    mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "CREATE DATABASE $TARGET_DB_ARG CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"
fi

# Création de l'utilisateur cible s'il n'existe pas déjà
if ! mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "SELECT User FROM mysql.user WHERE User='$DEST_DATABASE_USER'" | grep -q "$DEST_DATABASE_USER"; then
    status_message "INFO" "Création de l'utilisateur '$DEST_DATABASE_USER'..."
    mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "CREATE USER '$DEST_DATABASE_USER'@'localhost' IDENTIFIED WITH mysql_native_password BY '$DEST_DATABASE_PASSWORD';"
    mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "CREATE USER '$DEST_DATABASE_USER'@'127.0.0.1' IDENTIFIED WITH mysql_native_password BY '$DEST_DATABASE_PASSWORD';"
    mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "CREATE USER '$DEST_DATABASE_USER'@'%' IDENTIFIED WITH mysql_native_password BY '$DEST_DATABASE_PASSWORD';"
fi

# Attribution des privilèges à l'utilisateur cible
status_message "INFO" "Attribution des privilèges à l'utilisateur '$DEST_DATABASE_USER'..."
mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "GRANT ALL PRIVILEGES ON $TARGET_DB_ARG.* TO '$DEST_DATABASE_USER'@'localhost';"
mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "GRANT ALL PRIVILEGES ON $TARGET_DB_ARG.* TO '$DEST_DATABASE_USER'@'127.0.0.1';"
mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "GRANT ALL PRIVILEGES ON $TARGET_DB_ARG.* TO '$DEST_DATABASE_USER'@'%';"
mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "FLUSH PRIVILEGES;"

# Vérification des arguments
if [ -z "$SOURCE_FILE" ] && [ -z "$SOURCE_HOST_ARG" ]; then
    status_message "INFO" "Utilisation des paramètres de configuration par défaut pour la migration."
fi

# Préparation du répertoire de sauvegarde temporaire
TEMP_DIR="/home/mysql_migration_$(date +%Y%m%d%H%M%S)"
mkdir -p "$TEMP_DIR"
status_message "INFO" "Répertoire temporaire créé: $TEMP_DIR"

# Migration depuis un serveur distant
if [ -z "$SOURCE_FILE" ]; then
    # Utilisation des paramètres de configuration ou des arguments
    DUMP_FILE="$TEMP_DIR/${SOURCE_DB_ARG}_dump.sql"
    status_message "INFO" "Connexion au serveur source $SOURCE_HOST_ARG via SSH pour extraire la base de données $SOURCE_DB_ARG..."
    
    # Construction de la commande mysqldump avec les options d'exclusion de tables
    MYSQLDUMP_CMD="mysqldump --default-character-set=utf8mb4 --single-transaction --routines --triggers --events"
    
    # Ajout des options d'exclusion de tables si spécifiées
    if [ ! -z "$EXCLUDE_TABLES_ARG" ]; then
        for TABLE in $(echo $EXCLUDE_TABLES_ARG | tr ',' ' '); do
            MYSQLDUMP_CMD="$MYSQLDUMP_CMD --ignore-table=$SOURCE_DB_ARG.$TABLE"
        done
    fi
    
    # Ajout des options de structure uniquement si demandé
    if [ "$NO_DATA" = true ]; then
        MYSQLDUMP_CMD="$MYSQLDUMP_CMD --no-data"
    fi
    
    # Ajout des tables spécifiques si demandé
    if [ ! -z "$ONLY_TABLES" ]; then
        MYSQLDUMP_CMD="$MYSQLDUMP_CMD $SOURCE_DB_ARG $ONLY_TABLES"
    else
        MYSQLDUMP_CMD="$MYSQLDUMP_CMD $SOURCE_DB_ARG"
    fi
    
    # Exécution de la commande mysqldump via SSH
    status_message "INFO" "Exécution de mysqldump via SSH pour extraire la base de données..."
    
    # Vérification et installation de sshpass si nécessaire
    if ! command -v sshpass &> /dev/null; then
        status_message "INFO" "Installation de sshpass pour l'authentification automatique..."
        if command -v apt-get &> /dev/null; then
            apt-get update && apt-get install -y sshpass
        elif command -v yum &> /dev/null; then
            yum install -y sshpass
        else
            status_message "WARNING" "sshpass non disponible, utilisation de la méthode manuelle"
        fi
    fi
    
    # Configuration des options SSH
    SSH_OPTIONS="-o StrictHostKeyChecking=no"
    if [ ! -z "$SSH_KEY_PATH" ]; then
        SSH_OPTIONS="$SSH_OPTIONS -i $SSH_KEY_PATH"
    fi
    
    # Exécution directe de la commande mysqldump via SSH avec mot de passe
    status_message "INFO" "Exécution de mysqldump via SSH sur le serveur distant..."
    if [ ! -z "$SSH_PASSWORD" ] && command -v sshpass &> /dev/null; then
        sshpass -p "$SSH_PASSWORD" ssh $SSH_OPTIONS root@$SOURCE_HOST_ARG "$MYSQLDUMP_CMD" > "$DUMP_FILE"
    else
        ssh $SSH_OPTIONS root@$SOURCE_HOST_ARG "$MYSQLDUMP_CMD" > "$DUMP_FILE"
    fi
    
    if [ $? -ne 0 ]; then
        status_message "ERROR" "Erreur lors de l'extraction de la base de données via SSH."
        exit 1
    fi
    
    status_message "OK" "Base de données extraite avec succès: $DUMP_FILE"
    SOURCE_FILE="$DUMP_FILE"
fi

# Vérification du fichier source
if [ ! -f "$SOURCE_FILE" ]; then
    status_message "ERROR" "Le fichier source '$SOURCE_FILE' n'existe pas"
    exit 1
fi

# La vérification des tables existantes est déjà faite au début du script

# Traitement du fichier SQL pour remplacer les domaines et les définisseurs de triggers
PROCESSED_FILE="$TEMP_DIR/processed_dump.sql"
status_message "INFO" "Préparation du fichier SQL pour l'importation..."

# Détection du type de fichier (compressé ou non)
if [[ "$SOURCE_FILE" == *.gz ]]; then
    status_message "INFO" "Décompression du fichier source..."
    gunzip -c "$SOURCE_FILE" > "$TEMP_DIR/uncompressed_dump.sql"
    UNCOMPRESSED_FILE="$TEMP_DIR/uncompressed_dump.sql"
else
    UNCOMPRESSED_FILE="$SOURCE_FILE"
fi

# Remplacement des définisseurs de triggers et des domaines
status_message "INFO" "Remplacement des définisseurs de triggers et des domaines..."
if [ "$SKIP_DOMAIN_REPLACE" = false ] && [ ! -z "$OLD_DOMAIN_ARG" ] && [ ! -z "$NEW_DOMAIN_ARG" ]; then
    # Remplacer à la fois les définisseurs et les domaines
    sed -e "s/DEFINER=\`[^\`]*\`@\`[^\`]*\`/DEFINER=\`$DEST_DATABASE_USER\`@\`localhost\`/g" \
        -e "s/$OLD_DOMAIN_ARG/$NEW_DOMAIN_ARG/g" \
        "$UNCOMPRESSED_FILE" > "$PROCESSED_FILE"
    
    status_message "OK" "Remplacement des définisseurs et du domaine effectués avec succès."
else
    # Remplacer uniquement les définisseurs
    sed "s/DEFINER=\`[^\`]*\`@\`[^\`]*\`/DEFINER=\`$DEST_DATABASE_USER\`@\`localhost\`/g" \
        "$UNCOMPRESSED_FILE" > "$PROCESSED_FILE"
    
    status_message "OK" "Remplacement des définisseurs effectué avec succès."
fi

IMPORT_FILE="$PROCESSED_FILE"

# Importation de la base de données
status_message "INFO" "Importation de la base de données dans $TARGET_DB_ARG..."

# Détection du type de fichier (compressé ou non)
if [[ "$IMPORT_FILE" == *.gz ]] && [[ "$IMPORT_FILE" != "$PROCESSED_FILE" ]]; then
    status_message "INFO" "Décompression et importation du fichier $IMPORT_FILE..."
    gunzip -c "$IMPORT_FILE" | mysql -u root -p"$MYSQL_ROOT_PASSWORD" "$TARGET_DB_ARG"
else
    status_message "INFO" "Importation du fichier $IMPORT_FILE..."
    mysql -u root -p"$MYSQL_ROOT_PASSWORD" "$TARGET_DB_ARG" < "$IMPORT_FILE"
fi

if [ $? -ne 0 ]; then
    status_message "ERROR" "Erreur lors de l'importation de la base de données."
    exit 1
fi

status_message "OK" "Base de données importée avec succès dans $TARGET_DB_ARG."

# Optimisation des tables après importation
status_message "INFO" "Optimisation des tables de la base de données $TARGET_DB_ARG..."
mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "SHOW TABLES FROM $TARGET_DB_ARG" | grep -v "Tables_in" | while read table; do
    status_message "INFO" "Optimisation de la table $table..."
    mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "ANALYZE TABLE $TARGET_DB_ARG.$table;"
done

# Vérification des triggers dans la base de données
status_message "INFO" "Vérification des triggers dans la base de données..."

# Compter les triggers dans la base cible
TRIGGER_COUNT=$(mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "SELECT COUNT(*) FROM INFORMATION_SCHEMA.TRIGGERS WHERE TRIGGER_SCHEMA = '$TARGET_DB_ARG';" | tail -n 1)
status_message "INFO" "Nombre de triggers dans la base de données cible: $TRIGGER_COUNT"

# Si aucun trigger n'est trouvé ou si le nombre est faible, vérifier les triggers dans le fichier dump
if [ "$TRIGGER_COUNT" -lt 10 ]; then
    status_message "WARNING" "Peu ou pas de triggers trouvés dans la base de données cible. Vérification du fichier dump..."
    
    # Compter les triggers dans le fichier dump
    DUMP_TRIGGER_COUNT=$(grep -c "CREATE .* TRIGGER" "$UNCOMPRESSED_FILE" 2>/dev/null || echo 0)
    status_message "INFO" "Nombre de triggers trouvés dans le fichier dump: $DUMP_TRIGGER_COUNT"
    
    if [ "$DUMP_TRIGGER_COUNT" -gt "$TRIGGER_COUNT" ]; then
        status_message "WARNING" "Des triggers sont manquants dans la base importée. Tentative de récupération..."
        
        # Extraire les définitions de triggers du fichier dump et les appliquer directement
        TRIGGER_TEMP_FILE="$TEMP_DIR/triggers_only.sql"
        status_message "INFO" "Extraction des triggers du fichier dump..."
        
        # Utiliser awk pour extraire les définitions de triggers
        awk '/DELIMITER \$\$/ {trigger=1; print; next} /DELIMITER ;/ {if(trigger) {print; trigger=0}} {if(trigger) print}' "$UNCOMPRESSED_FILE" > "$TRIGGER_TEMP_FILE"
        
        # Modifier les définisseurs dans le fichier de triggers
        sed -i "s/DEFINER=\`[^\`]*\`@\`[^\`]*\`/DEFINER=\`$DEST_DATABASE_USER\`@\`localhost\`/g" "$TRIGGER_TEMP_FILE"
        
        # Importer les triggers
        status_message "INFO" "Importation des triggers..."
        mysql -u root -p"$MYSQL_ROOT_PASSWORD" "$TARGET_DB_ARG" < "$TRIGGER_TEMP_FILE"
        
        # Vérifier à nouveau le nombre de triggers
        NEW_TRIGGER_COUNT=$(mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "SELECT COUNT(*) FROM INFORMATION_SCHEMA.TRIGGERS WHERE TRIGGER_SCHEMA = '$TARGET_DB_ARG';" | tail -n 1)
        
        if [ "$NEW_TRIGGER_COUNT" -gt "$TRIGGER_COUNT" ]; then
            status_message "OK" "$((NEW_TRIGGER_COUNT - TRIGGER_COUNT)) triggers ont été ajoutés avec succès."
        else
            status_message "WARNING" "Aucun nouveau trigger n'a pu être ajouté. Tentative alternative..."
            
            # Tentative alternative : extraire chaque trigger individuellement
            status_message "INFO" "Extraction manuelle des triggers du fichier dump..."
            
            # Créer un script temporaire pour extraire et exécuter les triggers
            EXTRACT_SCRIPT="$TEMP_DIR/extract_triggers.sh"
            
            cat > "$EXTRACT_SCRIPT" << 'EOF'
#!/bin/bash
INPUT_FILE="$1"
OUTPUT_DIR="$2"
DB_NAME="$3"
USER="$4"

# Créer le répertoire de sortie s'il n'existe pas
mkdir -p "$OUTPUT_DIR"

# Trouver toutes les lignes contenant "CREATE TRIGGER"
grep -n "CREATE.*TRIGGER" "$INPUT_FILE" | while read -r line; do
    # Extraire le numéro de ligne et le nom du trigger
    LINE_NUM=$(echo "$line" | cut -d':' -f1)
    TRIGGER_NAME=$(echo "$line" | grep -o "TRIGGER \`[^\`]*\`" | sed 's/TRIGGER \`\(.*\)\`/\1/')
    
    if [ -n "$TRIGGER_NAME" ]; then
        echo "Traitement du trigger: $TRIGGER_NAME (ligne $LINE_NUM)"
        
        # Extraire la définition complète du trigger
        START_LINE=$LINE_NUM
        END_LINE=$(tail -n +$START_LINE "$INPUT_FILE" | grep -n "END" | head -1 | cut -d':' -f1)
        END_LINE=$((START_LINE + END_LINE))
        
        # Extraire la définition du trigger
        sed -n "${START_LINE},${END_LINE}p" "$INPUT_FILE" > "$OUTPUT_DIR/${TRIGGER_NAME}.sql"
        
        # Ajouter les délimiteurs
        sed -i '1s/^/DELIMITER $$\n/' "$OUTPUT_DIR/${TRIGGER_NAME}.sql"
        echo -e "\nDELIMITER ;" >> "$OUTPUT_DIR/${TRIGGER_NAME}.sql"
        
        # Remplacer le définisseur
        sed -i "s/DEFINER=\`[^\`]*\`@\`[^\`]*\`/DEFINER=\`$USER\`@\`localhost\`/g" "$OUTPUT_DIR/${TRIGGER_NAME}.sql"
    fi
done
EOF
            
            # Rendre le script exécutable
            chmod +x "$EXTRACT_SCRIPT"
            
            # Exécuter le script pour extraire les triggers
            TRIGGERS_DIR="$TEMP_DIR/triggers"
            "$EXTRACT_SCRIPT" "$UNCOMPRESSED_FILE" "$TRIGGERS_DIR" "$TARGET_DB_ARG" "$DEST_DATABASE_USER"
            
            # Importer chaque trigger individuellement
            if [ -d "$TRIGGERS_DIR" ]; then
                for TRIGGER_FILE in "$TRIGGERS_DIR"/*.sql; do
                    if [ -f "$TRIGGER_FILE" ]; then
                        TRIGGER_NAME=$(basename "$TRIGGER_FILE" .sql)
                        status_message "INFO" "Importation du trigger $TRIGGER_NAME..."
                        mysql -u root -p"$MYSQL_ROOT_PASSWORD" "$TARGET_DB_ARG" < "$TRIGGER_FILE"
                    fi
                done
                
                # Vérifier à nouveau le nombre de triggers
                FINAL_TRIGGER_COUNT=$(mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "SELECT COUNT(*) FROM INFORMATION_SCHEMA.TRIGGERS WHERE TRIGGER_SCHEMA = '$TARGET_DB_ARG';" | tail -n 1)
                
                if [ "$FINAL_TRIGGER_COUNT" -gt "$TRIGGER_COUNT" ]; then
                    status_message "OK" "$((FINAL_TRIGGER_COUNT - TRIGGER_COUNT)) triggers ont été ajoutés avec succès."
                else
                    status_message "WARNING" "Impossible d'ajouter les triggers manquants. Vérifiez manuellement."
                fi
            fi
        fi
    else
        status_message "INFO" "Aucun trigger trouvé dans le fichier dump."
    fi
else
    status_message "OK" "$TRIGGER_COUNT triggers trouvés dans la base de données."
fi

# Nettoyage des fichiers temporaires
status_message "INFO" "Nettoyage des fichiers temporaires..."
rm -rf "$TEMP_DIR"

# Résumé de la migration
status_message "OK" "====================================================================="
status_message "OK" "Migration de la base de données terminée avec succès!"
status_message "OK" "====================================================================="
status_message "INFO" "Base de données source: $SOURCE_DB_ARG"
status_message "INFO" "Base de données cible: $TARGET_DB_ARG"

if [ "$SKIP_DOMAIN_REPLACE" = false ] && [ ! -z "$OLD_DOMAIN_ARG" ] && [ ! -z "$NEW_DOMAIN_ARG" ]; then
    status_message "INFO" "Domaine remplacé: $OLD_DOMAIN_ARG -> $NEW_DOMAIN_ARG"
fi

if [ ! -z "$EXCLUDE_TABLES_ARG" ]; then
    status_message "INFO" "Tables exclues: $EXCLUDE_TABLES_ARG"
fi

status_message "INFO" "Utilisateur MySQL créé: $DEST_DATABASE_USER"
status_message "OK" "====================================================================="

# Vérification que MySQL est en cours d'exécution
if ! systemctl is-active --quiet mysqld; then
    echo "MySQL n'est pas en cours d'exécution. Démarrage de MySQL..."
    systemctl start mysqld
    
    if ! systemctl is-active --quiet mysqld; then
        echo "Impossible de démarrer MySQL. Vérifiez les logs avec: journalctl -u mysqld"
        exit 1
    fi
fi

# Vérification de la connexion avec le mot de passe root
echo "Vérification de la connexion avec le mot de passe root..."
if ! mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "SELECT 'Connexion réussie' AS Status;" &>/dev/null; then
    echo "Impossible de se connecter à MySQL avec le mot de passe root."
    echo "Veuillez exécuter le script 03_configure_mysql.sh pour configurer correctement les utilisateurs."
    exit 1
fi

# Vérification de l'existence de la base de données
echo "Vérification de l'existence de la base de données $MYSQL_DATABASE..."
DB_EXISTS=$(mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME='$MYSQL_DATABASE';" | grep -c "$MYSQL_DATABASE")

if [ "$DB_EXISTS" -eq 0 ]; then
    echo "La base de données $MYSQL_DATABASE n'existe pas. Création de la base de données..."
    mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "CREATE DATABASE \`$MYSQL_DATABASE\` CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;"
    
    if [ $? -ne 0 ]; then
        echo "Erreur lors de la création de la base de données $MYSQL_DATABASE"
        exit 1
    fi
    
    echo "Base de données $MYSQL_DATABASE créée avec succès."
else
    echo "La base de données $MYSQL_DATABASE existe déjà."
    
    # Vérification si la base de données contient des tables
    TABLE_COUNT=$(mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "SELECT COUNT(TABLE_NAME) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='$MYSQL_DATABASE';" | tail -n 1)
    
    if [ "$TABLE_COUNT" -gt 0 ]; then
        echo "La base de données contient déjà $TABLE_COUNT tables."
        read -p "Voulez-vous supprimer toutes les tables existantes avant l'importation ? (o/n): " CONFIRM
        
        if [[ "$CONFIRM" =~ ^[Oo]$ ]]; then
            echo "Suppression de toutes les tables de la base de données $MYSQL_DATABASE..."
            mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "
                SET FOREIGN_KEY_CHECKS = 0;
                SELECT CONCAT('DROP TABLE IF EXISTS \`', table_name, '\`;') 
                FROM information_schema.tables 
                WHERE table_schema = '$MYSQL_DATABASE';
            " | grep -v "CONCAT" | while read -r cmd; do
                echo "Exécution de: $cmd"
                mysql -u root -p"$MYSQL_ROOT_PASSWORD" -D "$MYSQL_DATABASE" -e "$cmd"
            done
            mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "SET FOREIGN_KEY_CHECKS = 1;"
            
            echo "Toutes les tables ont été supprimées de la base de données $MYSQL_DATABASE."
        else
            echo "Les tables existantes seront conservées. L'importation pourrait échouer en cas de conflit."
        fi
    fi
fi

# Migration depuis un fichier
if [ ! -z "$SOURCE_FILE" ]; then
    echo "Migration depuis le fichier $SOURCE_FILE..."
    
    # Préparation des options pour mysqldump
    IMPORT_OPTIONS=""
    
    if [ "$NO_DATA" = true ]; then
        IMPORT_OPTIONS="--no-data"
    fi
    
    # Importation du fichier SQL
    if [[ "$SOURCE_FILE" == *.gz ]]; then
        echo "Importation du fichier SQL compressé..."
        gunzip -c "$SOURCE_FILE" | mysql -u root -p"$MYSQL_ROOT_PASSWORD" "$MYSQL_DATABASE"
    else
        echo "Importation du fichier SQL..."
        mysql -u root -p"$MYSQL_ROOT_PASSWORD" "$MYSQL_DATABASE" < "$SOURCE_FILE"
    fi
    
    if [ $? -ne 0 ]; then
        echo "Erreur lors de l'importation du fichier $SOURCE_FILE"
        exit 1
    fi
    
    echo "Importation du fichier $SOURCE_FILE terminée avec succès."
fi

# Migration depuis un serveur source
if [ ! -z "$SOURCE_HOST" ]; then
    echo "Migration depuis le serveur source $SOURCE_HOST..."
    
    # Vérification de la connexion au serveur source
    echo "Vérification de la connexion au serveur source..."
    if ! mysql -h "$SOURCE_HOST" -u "$SOURCE_USER" -p"$SOURCE_PASS" -e "SELECT 'Connexion réussie' AS Status;" &>/dev/null; then
        echo "Impossible de se connecter au serveur source."
        exit 1
    fi
    
    # Préparation des options pour mysqldump
    DUMP_OPTIONS="--single-transaction --quick --add-drop-table --routines --triggers --events"
    
    if [ "$NO_DATA" = true ]; then
        DUMP_OPTIONS="$DUMP_OPTIONS --no-data"
    fi
    
    if [ ! -z "$ONLY_TABLES" ]; then
        # Conversion de la liste de tables en arguments pour mysqldump
        IFS=',' read -ra TABLES <<< "$ONLY_TABLES"
        for table in "${TABLES[@]}"; do
            DUMP_OPTIONS="$DUMP_OPTIONS $table"
        done
    elif [ ! -z "$EXCLUDE_TABLES" ]; then
        # Conversion de la liste de tables en arguments pour mysqldump
        IFS=',' read -ra TABLES <<< "$EXCLUDE_TABLES"
        for table in "${TABLES[@]}"; do
            DUMP_OPTIONS="$DUMP_OPTIONS --ignore-table=$SOURCE_DB.$table"
        done
    fi
    
    # Création d'un répertoire temporaire pour la sauvegarde
    TEMP_DIR="/home/mysql_migration_local_$(date +%Y%m%d%H%M%S)"
    mkdir -p "$TEMP_DIR"
    DUMP_FILE="$TEMP_DIR/dump.sql"
    
    echo "Exportation de la base de données source..."
    mysqldump -h "$SOURCE_HOST" -u "$SOURCE_USER" -p"$SOURCE_PASS" $DUMP_OPTIONS "$SOURCE_DB" > "$DUMP_FILE"
    
    if [ $? -ne 0 ]; then
        echo "Erreur lors de l'exportation de la base de données source"
        rm -rf "$TEMP_DIR"
        exit 1
    fi
    
    echo "Importation de la base de données source..."
    mysql -u root -p"$MYSQL_ROOT_PASSWORD" "$MYSQL_DATABASE" < "$DUMP_FILE"
    
    if [ $? -ne 0 ]; then
        echo "Erreur lors de l'importation de la base de données source"
        rm -rf "$TEMP_DIR"
        exit 1
    fi
    
    # Nettoyage
    rm -rf "$TEMP_DIR"
    
    echo "Migration depuis le serveur source terminée avec succès."
fi

# Optimisation des tables après l'importation
echo "Optimisation des tables après l'importation..."
mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "
SELECT CONCAT('OPTIMIZE TABLE ', table_schema, '.', table_name, ';') AS 'Optimize Command'
FROM information_schema.tables
WHERE table_schema = '$MYSQL_DATABASE'
AND engine = 'InnoDB';
" | grep -v "Optimize Command" | while read -r cmd; do
    echo "Exécution de: $cmd"
    mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "$cmd"
done

# Analyse des tables après l'importation
echo "Analyse des tables après l'importation..."
mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "
SELECT CONCAT('ANALYZE TABLE ', table_schema, '.', table_name, ';') AS 'Analyze Command'
FROM information_schema.tables
WHERE table_schema = '$MYSQL_DATABASE'
AND engine = 'InnoDB';
" | grep -v "Analyze Command" | while read -r cmd; do
    echo "Exécution de: $cmd"
    mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "$cmd"
done

# Vérification des tables importées
echo "Vérification des tables importées..."
TABLE_COUNT=$(mysql -u root -p"$MYSQL_ROOT_PASSWORD" -e "SELECT COUNT(TABLE_NAME) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='$MYSQL_DATABASE';" | tail -n 1)

echo "====================================================================="
echo "Migration de la base de données terminée avec succès."
echo ""
echo "Base de données: $MYSQL_DATABASE"
echo "Nombre de tables: $TABLE_COUNT"
echo ""
echo "Vous pouvez maintenant accéder à la base de données avec les informations suivantes:"
echo "  Hôte: $SERVER_IP"
echo "  Port: $MYSQL_PORT"
echo "  Base de données: $MYSQL_DATABASE"
echo "  Utilisateur: $MYSQL_USER"
echo "  Mot de passe: $MYSQL_PASSWORD"
echo "====================================================================="