#!/bin/bash

# Script de remplacement de variables et copie vers storage/
# Remplace les variables d'environnement dans les fichiers générés et les copie vers storage/

set -euo pipefail

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

# Fonctions d'affichage
print_error() { echo -e "${RED}❌ ERREUR${NC}: $1"; }
print_success() { echo -e "${GREEN}✅ SUCCÈS${NC}: $1"; }
print_info() { echo -e "${BLUE}ℹ️  INFO${NC}: $1"; }
print_warning() { echo -e "${YELLOW}⚠️  ATTENTION${NC}: $1"; }
print_step() { echo -e "${CYAN}🔄 $1${NC}"; }

# Variables globales
TEMPLATES_DIR="$(pwd)"
STORAGE_DIR="../../storage/dev"
FILES_PROCESSED=0
FILES_COPIED=0

# Fonction pour charger toutes les variables d'environnement
load_all_env_vars() {
    print_step "Chargement des variables d'environnement"

    # Exporter automatiquement toutes les variables sourcées
    set -a

    local env_files=(".env.secrets" ".env")
    local total_vars=0

    for env_file in "${env_files[@]}"; do
        if [ -f "$env_file" ]; then
            print_info "Chargement de $env_file..."

            # Désactiver temporairement l'option 'set -u' pour éviter les erreurs sur les variables non définies
            set +u
            # Compter les variables avant le chargement
            local vars_before=$(env | wc -l)
            # shellcheck source=/dev/null
            source "$env_file" 2>/dev/null || {
                print_warning "Erreur lors du chargement de $env_file, tentative de chargement ligne par ligne"

                # Chargement ligne par ligne en ignorant les erreurs
                while IFS='=' read -r key value || [ -n "$key" ]; do
                    # Ignorer les commentaires et lignes vides
                    if [[ ! "$key" =~ ^[[:space:]]*# ]] && [[ -n "$key" ]]; then
                        # Nettoyer la clé et la valeur
                        key=$(echo "$key" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
                        value=$(echo "$value" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')

                        # Ignorer les tableaux bash (lignes avec des parenthèses)
                        if [[ ! "$key" =~ \($ ]] && [[ -n "$key" ]]; then
                            export "$key"="$value" 2>/dev/null || true
                            total_vars=$((total_vars + 1))
                        fi
                    fi
                done < "$env_file"
            }
            # Compter les variables après le chargement
            local vars_after=$(env | wc -l)
            local vars_added=$((vars_after - vars_before))
            total_vars=$((total_vars + vars_added))
            print_info "Variables ajoutées depuis $env_file: $vars_added"

            # Exporter toutes les variables définies dans ce fichier
            if [ -f "$env_file" ]; then
                while IFS='=' read -r key value || [ -n "$key" ]; do
                    # Ignorer les commentaires et lignes vides
                    if [[ ! "$key" =~ ^[[:space:]]*# ]] && [[ -n "$key" ]]; then
                        # Nettoyer la clé et la valeur
                        key=$(echo "$key" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
                        value=$(echo "$value" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')

                        # Ignorer les tableaux bash (lignes avec des parenthèses)
                        if [[ ! "$key" =~ \($ ]] && [[ -n "$key" ]]; then
                            export "$key"="$value" 2>/dev/null || true
                        fi
                    fi
                done < "$env_file"
            fi

            # Réactiver l'option 'set -u'
            set -u
        else
            print_warning "Fichier $env_file non trouvé, ignoré"
        fi
    done

    # Traiter .env.auto pour charger les variables générées
    if [ -f ".env.auto" ]; then
        print_info "Traitement de .env.auto pour charger les variables générées..."
        local temp_env=$(mktemp)
        envsubst < .env.auto > "$temp_env"
        source "$temp_env" 2>/dev/null || {
            print_warning "Erreur lors du chargement de .env.auto traité"
        }
        rm -f "$temp_env"
    fi

    # Traiter .env.post pour charger les variables finales
    if [ -f ".env.post" ]; then
        print_info "Traitement de .env.post pour charger les variables finales..."
        local temp_env=$(mktemp)
        envsubst < .env.post > "$temp_env"
        source "$temp_env" 2>/dev/null || {
            print_warning "Erreur lors du chargement de .env.post traité"
        }
        rm -f "$temp_env"
    fi

    # Désactiver l'export automatique
    set +a

    print_success "$total_vars variables d'environnement chargées"
}

# Fonction pour remplacer les variables dans un fichier
replace_variables_in_file() {
    local input_file="$1"
    local output_file="$2"

    if [ ! -f "$input_file" ]; then
        print_warning "Fichier source $input_file non trouvé, ignoré"
        return 1
    fi

    print_info "Traitement de $input_file -> $output_file"

    # Créer le répertoire de destination si nécessaire
    mkdir -p "$(dirname "$output_file")"

    # Copier le fichier et remplacer les variables
    cp "$input_file" "$output_file"

    # Remplacer toutes les variables $VARIABLE par leurs valeurs
    # Utiliser envsubst pour le remplacement sécurisé avec résolution multi-passes
    if command -v envsubst >/dev/null 2>&1; then
        # Faire plusieurs passes pour résoudre les variables imbriquées
        local temp_file1=$(mktemp)
        local temp_file2=$(mktemp)

        # Première passe
        envsubst < "$input_file" > "$temp_file1"

        # Faire jusqu'à 5 passes pour résoudre les variables imbriquées
        for i in {1..5}; do
            # Vérifier s'il y a encore des variables non résolues
            if grep -q '\$[A-Za-z_][A-Za-z0-9_]*' "$temp_file1"; then
                # Passer par envsubst
                envsubst < "$temp_file1" > "$temp_file2"
                # Échanger les fichiers
                mv "$temp_file2" "$temp_file1"
            else
                break
            fi
        done

        # Copier le résultat final
        cp "$temp_file1" "$output_file"

        # Nettoyer les fichiers temporaires
        rm -f "$temp_file1" "$temp_file2"
    else
        print_warning "envsubst non disponible, utilisation de sed pour le remplacement basique"

        # Méthode de remplacement basique avec sed
        local temp_file=$(mktemp)
        cp "$input_file" "$temp_file"

        # Remplacer les variables une par une
        while IFS='=' read -r key value || [ -n "$key" ]; do
            if [[ ! "$key" =~ ^[[:space:]]*# ]] && [[ -n "$key" ]]; then
                key=$(echo "$key" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
                if [[ -n "$key" ]]; then
                    # Échapper les caractères spéciaux dans la valeur
                    escaped_value=$(echo "$value" | sed 's/[[\.*^$()+?{|]/\\&/g')
                    # Remplacer \$KEY par la valeur
                    sed -i "s|\\\$${key}|${escaped_value}|g" "$temp_file"
                fi
            fi
        done < <(env | grep -v '^_')

        mv "$temp_file" "$output_file"
    fi

    FILES_PROCESSED=$((FILES_PROCESSED + 1))
    print_success "Variables remplacées dans $input_file"
}

# Fonction pour copier un fichier vers storage/
copy_file_to_storage() {
    local source_file="$1"
    local relative_path="$2"
    local dest_file="$STORAGE_DIR/$relative_path"

    if [ ! -f "$source_file" ]; then
        print_warning "Fichier source $source_file non trouvé, ignoré"
        return 1
    fi

    print_info "Copie de $source_file vers $dest_file"

    # Créer le répertoire de destination si nécessaire
    mkdir -p "$(dirname "$dest_file")"

    # Copier le fichier
    cp "$source_file" "$dest_file"

    FILES_COPIED=$((FILES_COPIED + 1))
    print_success "Fichier copié: $relative_path"
}

# Fonction pour traiter un fichier (remplacer variables + copier)
process_and_copy_file() {
    local source_file="$1"
    local relative_path="$2"

    # Créer un fichier temporaire avec les variables remplacées
    local temp_file=$(mktemp)

    # Remplacer les variables dans le fichier source
    if replace_variables_in_file "$source_file" "$temp_file"; then
        # Copier le fichier traité vers storage/
        copy_file_to_storage "$temp_file" "$relative_path"
    fi

    # Nettoyer le fichier temporaire
    rm -f "$temp_file"
}

# Fonction pour traiter un répertoire récursivement
process_directory() {
    local source_dir="$1"
    local relative_base="$2"

    if [ ! -d "$source_dir" ]; then
        print_warning "Répertoire source $source_dir non trouvé, ignoré"
        return 1
    fi

    print_step "Traitement du répertoire $source_dir"

    # Traiter tous les fichiers dans le répertoire (sauf _keys)
    find "$source_dir" -type f -not -path "*/_keys/*" | while read -r file; do
        # Calculer le chemin relatif
        local relative_path="${file#$source_dir/}"
        local full_relative_path="$relative_base/$relative_path"

        # Traiter le fichier
        process_and_copy_file "$file" "$full_relative_path"
    done
}

# Fonction principale
main() {
    echo -e "${BLUE}🚀 REMPLACEMENT DE VARIABLES ET COPIE VERS STORAGE${NC}"
    echo -e "${BLUE}==================================================${NC}"

    # Vérifier que nous sommes dans le bon répertoire
    if [ ! -f "generate_variables.sh" ]; then
        print_error "Script generate_variables.sh non trouvé. Assurez-vous d'être dans templates/dev/"
        exit 1
    fi

    # Charger toutes les variables d'environnement
    load_all_env_vars

    # Vérifier que le répertoire storage existe
    if [ ! -d "$STORAGE_DIR" ]; then
        print_error "Répertoire storage non trouvé: $STORAGE_DIR"
        exit 1
    fi

    print_step "Début du traitement des fichiers"

    # Traiter les fichiers individuels
    print_step "Traitement des fichiers individuels"

    # Variables d'environnement
    [ -f ".env.auto" ] && process_and_copy_file ".env.auto" ".env.auto"

    # Docker Compose
    [ -f "docker-compose.yml.auto" ] && process_and_copy_file "docker-compose.yml.auto" "docker-compose.yml.auto"

    # Traiter les répertoires
    print_step "Traitement des répertoires"

    # Modules 4NK (avec underscore)
    [ -d "_4NK_modules" ] && process_directory "_4NK_modules" "_4NK_modules"

    # Modules 4NK (sans underscore) - DÉSACTIVÉ car générés dans _4NK_modules
    # [ -d "4NK_modules" ] && process_directory "4NK_modules" "4NK_modules"

    # Configurations logrotate
    [ -d "logrotade" ] && process_directory "logrotade" "logrotade"

    # Configurations nginx - DÉSACTIVÉ car généré dans _4NK_modules/nginx
    # [ -d "nginx" ] && process_directory "nginx" "nginx"

    # Configuration git
    [ -d "git" ] && process_directory "git" "git"

    # Monitoring
    [ -d "monitoring" ] && process_directory "monitoring" "monitoring"

    # Projets
    [ -d "projects" ] && process_directory "projects" "projects"

    # Supervisor
    [ -d "supervisor" ] && process_directory "supervisor" "supervisor"

    # Clés et certificats (EXCLUSION - ne pas traiter)
    # [ -d "_keys" ] && process_directory "_keys" "_keys"  # DÉSACTIVÉ - répertoire sensible

    # Afficher le résumé
    echo -e "\n${PURPLE}📊 RÉSUMÉ DU TRAITEMENT${NC}"
    echo -e "${PURPLE}========================${NC}"
    echo -e "Fichiers traités: ${GREEN}$FILES_PROCESSED${NC}"
    echo -e "Fichiers copiés: ${GREEN}$FILES_COPIED${NC}"
    echo -e "Répertoire source: ${CYAN}$TEMPLATES_DIR${NC}"
    echo -e "Répertoire destination: ${CYAN}$STORAGE_DIR${NC}"

    if [ $FILES_COPIED -gt 0 ]; then
        print_success "Traitement terminé avec succès !"
        echo -e "\n${CYAN}🚀 Prochaines étapes:${NC}"
        echo -e "  1. Vérifiez les fichiers dans $STORAGE_DIR"
        echo -e "  2. Testez les configurations générées"
        echo -e "  3. Déployez si nécessaire"
    else
        print_warning "Aucun fichier n'a été traité"
        echo -e "\n${YELLOW}🔧 Vérifications recommandées:${NC}"
        echo -e "  1. Vérifiez que les scripts de génération ont été exécutés"
        echo -e "  2. Vérifiez que les fichiers sources existent dans templates/dev/"
        echo -e "  3. Vérifiez les variables d'environnement"
    fi
}

# Exécuter le script principal
main "$@"