#!/bin/bash

# Script pour générer automatiquement les configurations Nginx
# basées sur les modules définis dans les variables d'environnement

# Fonction pour charger les variables d'environnement
load_env_files() {
    local env_files=(".env.secrets" ".env" ".env.auto" ".env.post")

    for env_file in "${env_files[@]}"; do
        if [ -f "$env_file" ]; then
            echo "📄 Chargement de $env_file..."
            source "$env_file" 2>/dev/null || true
        else
            echo "⚠️  Fichier $env_file non trouvé, ignoré."
        fi
    done
}

# Fonction pour générer les upstreams
generate_upstreams() {
    echo "🔧 Génération du fichier upstreams.conf"

    # Créer le répertoire si nécessaire
    mkdir -p "nginx"

    # Générer le fichier upstreams.conf
    cat > "nginx/upstreams.conf" << 'EOF'
# Upstreams générés automatiquement
# Généré le $(date)

EOF

    # Ajouter le format de log JSON
    cat >> "nginx/upstreams.conf" << 'EOF'
log_format app_json escape=json
  '{ "time":"$time_iso8601",'
  '  "client":"$remote_addr",'
  '  "xff":"$http_x_forwarded_for",'
  '  "method":"$request_method",'
  '  "host":"$host",'
  '  "uri":"$request_uri",'
  '  "status":$status,'
  '  "bytes":$body_bytes_sent,'
  '  "ua":"$http_user_agent",'
  '  "upstream":"$upstream_addr",'
  '  "rt":$request_time,'
  '  "urt":$upstream_response_time }';

EOF

    # Générer les upstreams pour chaque service
    for SERVICE_VAR in "${SERVICES[@]}"; do
        echo "  🔄 Génération upstream pour $SERVICE_VAR"

        cat >> "nginx/upstreams.conf" << EOF

upstream \$${SERVICE_VAR} {
    server \$${SERVICE_VAR}_DOCKER_NAME:\$${SERVICE_VAR}_PORT;
    keepalive 64;
}
EOF
    done

    echo "✅ Fichier upstreams.conf généré"
}

# Fonction pour générer les configurations internes
generate_internal_configs() {
    echo "🔧 Génération du fichier app-internal-ports.conf"

    # Créer le répertoire si nécessaire
    mkdir -p "nginx"

    # Générer le fichier app-internal-ports.conf
    cat > "nginx/app-internal-ports.conf" << 'EOF'
# Configurations internes générées automatiquement
# Généré le $(date)

EOF

    # Générer les configurations internes pour chaque service
    for SERVICE_VAR in "${SERVICES[@]}"; do
        echo "  🔄 Génération config interne pour $SERVICE_VAR"

        cat >> "nginx/app-internal-ports.conf" << EOF

server {
   listen \$${SERVICE_VAR}_PORT default_server;
    server_name _;                       # pas d'host requis
    access_log \$$NGINX_LOGS_DIR/\$${SERVICE_VAR}_int.log app_json;

    location / {
        proxy_pass http://\$${SERVICE_VAR}_DOCKER_NAME;
        include \$$NGINX_CONFS_DIR/proxy_headers.conf;
    }

    # websocket (si nécessaire)
    location /ws/ {
        proxy_pass http://\$${SERVICE_VAR}_DOCKER_NAME;
        proxy_http_version 1.1;
        proxy_set_header Upgrade    \$http_upgrade;
        proxy_set_header Connection "upgrade";
        include \$$NGINX_CONFS_DIR/proxy_headers.conf;
        proxy_read_timeout 3600s;
    }
}
EOF
    done

    echo "✅ Fichier app-internal-ports.conf généré"
}

# Fonction pour générer les configurations HTTPS individuelles
generate_https_configs() {
    echo "🔧 Génération des configurations HTTPS individuelles"

    # Générer une configuration HTTPS pour chaque service
    for SERVICE_VAR in "${SERVICES[@]}"; do
        echo "  🔄 Génération config HTTPS pour $SERVICE_VAR"

        local CONFIG_FILE="nginx/${SERVICE_VAR}_https.conf"

        cat > "$CONFIG_FILE" << EOF
# Configuration HTTPS pour $SERVICE_VAR
# Généré automatiquement le $(date)

server {
    listen 80;
    server_name \$${SERVICE_VAR}.\$$DOMAIN;
    # redirection HTTP→HTTPS pour l'externe
    return 301 https://\$host\$request_uri;
}

server {
    listen 443 ssl http2;
    server_name \$${SERVICE_VAR}_DOCKER_NAME.\$$DOMAIN;

ssl_certificate     /etc/letsencrypt/live/$HOST/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/$HOST/privkey.pem;


    # réglages TLS minimaux (adapter selon politique)
    ssl_session_timeout  1d;
    ssl_protocols        TLSv1.2 TLSv1.3;
    ssl_ciphers          HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;

    # HSTS (activer seulement si tout le domaine est en HTTPS)
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

    access_log \$$NGINX_LOGS_DIR/\$${SERVICE_VAR}_https.log app_json;

    location / {
        proxy_pass http://\$${SERVICE_VAR}_DOCKER_NAME;
        include \$$NGINX_CONFS_DIR/proxy_headers.conf;
    }

    location /ws/ {
        proxy_pass http://\$${SERVICE_VAR}_DOCKER_NAME;
        proxy_http_version 1.1;
        proxy_set_header Upgrade    \$http_upgrade;
        proxy_set_header Connection "upgrade";
        include \$$NGINX_CONFS_DIR/proxy_headers.conf;
        proxy_read_timeout 3600s;
    }
}
EOF

        echo "    ✅ Config HTTPS générée: $CONFIG_FILE"
    done

    echo "✅ Configurations HTTPS individuelles générées"
}

# Fonction pour générer un fichier de configuration consolidé
generate_consolidated_https_config() {
    echo "🔧 Génération du fichier nginx_$HOST-https.conf consolidé"

    # Créer le répertoire si nécessaire
    mkdir -p "nginx"

    # Générer le fichier consolidé
    cat > "nginx/nginx_$HOST-https.conf" << 'EOF'
# Configuration Nginx consolidée pour $HOST
# Générée automatiquement le $(date)

# Inclusion du format de log JSON et des upstreams
include upstreams.conf;

EOF

    # Ajouter la redirection HTTP→HTTPS globale
    cat >> "nginx/nginx_$HOST-https.conf" << 'EOF'

# Redirection globale HTTP→HTTPS
server {
    listen 80;
    server_name $HOST *.$HOST;
    return 301 https://$host$request_uri;
}

EOF

    # Ajouter les configurations HTTPS pour chaque service
    for SERVICE_VAR in "${SERVICES[@]}"; do
        echo "  🔄 Ajout de la config HTTPS pour $SERVICE_VAR dans le fichier consolidé"

        cat >> "nginx/nginx_$HOST-https.conf" << EOF

# Configuration HTTPS pour $SERVICE_VAR
server {
    listen 80;
    server_name \$${SERVICE_VAR}.\$$DOMAIN;
    # redirection HTTP→HTTPS pour l'externe
    return 301 https://\$host\$request_uri;
}

server {
    listen 443 ssl http2;
    server_name \$${SERVICE_VAR}_DOCKER_NAME.\$$DOMAIN;

    ssl_certificate     \$$CERT_PATH/certs/fullchain.pem;
    ssl_certificate_key \$$CERT_PATH/private/privkey.pem;

    # réglages TLS minimaux (adapter selon politique)
    ssl_session_timeout  1d;
    ssl_protocols        TLSv1.2 TLSv1.3;
    ssl_ciphers          HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;

    # HSTS (activer seulement si tout le domaine est en HTTPS)
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

    access_log \$$NGINX_LOGS_DIR/\$${SERVICE_VAR}_https.log app_json;

    location / {
        proxy_pass http://\$${SERVICE_VAR}_DOCKER_NAME;
        include \$$NGINX_CONFS_DIR/proxy_headers.conf;
    }

    location /ws/ {
        proxy_pass http://\$${SERVICE_VAR}_DOCKER_NAME;
        proxy_http_version 1.1;
        proxy_set_header Upgrade    \$http_upgrade;
        proxy_set_header Connection "upgrade";
        include \$$NGINX_CONFS_DIR/proxy_headers.conf;
        proxy_read_timeout 3600s;
    }
}
EOF
    done

    echo "✅ Fichier nginx_$HOST-https.conf consolidé généré"
}

# Fonction pour créer les fichiers de configuration proxy_headers.conf
generate_proxy_headers() {
    echo "🔧 Génération du fichier proxy_headers.conf"

    # Créer le répertoire si nécessaire
    mkdir -p "nginx"

    # Générer le fichier proxy_headers.conf
    cat > "nginx/proxy_headers.conf" << 'EOF'
# Headers de proxy générés automatiquement
# Généré le $(date)

proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Forwarded-Host $host;
proxy_set_header X-Forwarded-Port $server_port;

# Directives de proxy
proxy_redirect off;                    # si l'app sait générer ses URLs
add_header X-Debug-Scheme $scheme always;
add_header X-Debug-XFP $http_x_forwarded_proto always;

# Timeouts
proxy_connect_timeout 60s;
proxy_send_timeout 60s;
proxy_read_timeout 60s;

# Buffer settings
proxy_buffering on;
proxy_buffer_size 4k;
proxy_buffers 8 4k;
proxy_busy_buffers_size 8k;

# Cache settings
proxy_cache_bypass $http_upgrade;
proxy_no_cache $http_upgrade;
EOF

    echo "✅ Fichier proxy_headers.conf généré"
}

# Générer le script de validation des templates
generate_deploy_script() {
    echo "🔧 Génération du script de validation des templates"

    cat > "nginx/validate_templates.sh" << 'EOF'
#!/bin/bash

# Script de validation des templates Nginx générés
# Généré automatiquement le $(date)

set -euo pipefail

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

# 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"; }

# Charger les variables d'environnement
if [ -f ".env" ]; then
    # Charger .env en mode silencieux pour éviter les erreurs de syntaxe
    source .env 2>/dev/null || true
fi

# Vérifier que HOST est défini
if [ -z "${HOST:-}" ]; then
    print_warning "Variable HOST non définie, utilisation de la valeur par défaut"
    export HOST="dev4._4NKweb.com"
fi

print_info "Validation des templates Nginx pour $HOST"

# Vérifier que les fichiers existent
missing_files=0

if [ ! -f "nginx/upstreams.conf" ]; then
    print_error "Template nginx/upstreams.conf non trouvé"
    missing_files=$((missing_files + 1))
fi

if [ ! -f "nginx/app-internal-ports.conf" ]; then
    print_error "Template nginx/app-internal-ports.conf non trouvé"
    missing_files=$((missing_files + 1))
fi

if [ ! -f "nginx/proxy_headers.conf" ]; then
    print_error "Template nginx/proxy_headers.conf non trouvé"
    missing_files=$((missing_files + 1))
fi

if [ ! -f "nginx/nginx_$HOST-https.conf" ]; then
    print_error "Template nginx/nginx_$HOST-https.conf non trouvé"
    missing_files=$((missing_files + 1))
fi

if [ $missing_files -eq 0 ]; then
    print_success "Tous les templates de configuration sont présents"
    print_info "Templates générés:"
    echo "  • nginx/upstreams.conf"
    echo "  • nginx/app-internal-ports.conf"
    echo "  • nginx/proxy_headers.conf"
    echo "  • nginx/*_https.conf (configurations HTTPS individuelles)"
    echo "  • nginx/nginx_$HOST-https.conf"

    print_info "Ces templates sont prêts à être utilisés dans votre infrastructure"
    print_warning "Adaptez les chemins et configurations selon vos besoins spécifiques"
else
    print_error "$missing_files template(s) manquant(s)"
    exit 1
fi

EOF

    chmod +x "nginx/validate_templates.sh"
    echo "✅ Script de validation des templates généré"
}

# Fonction principale
main() {
    echo "🚀 GÉNÉRATION AUTOMATIQUE DES CONFIGURATIONS NGINX"
    echo "=================================================="

    # Charger les variables d'environnement
    load_env_files

    # Vérifier que SERVICES est défini
    if [ -z "${SERVICES[*]}" ]; then
        print_error "Variable SERVICES non définie"
        echo "   Assurez-vous que SERVICES=(service1 service2 ...) est défini dans .env"
        exit 1
    fi

    echo "📋 Génération des configurations pour ${#SERVICES[@]} services..."
    echo "   Services: ${SERVICES[*]}"

    # Supprimer les fichiers de sortie existants (remplacer complètement)
    rm -f "nginx/upstreams.conf" 2>/dev/null || true
    rm -f "nginx/app-internal-ports.conf" 2>/dev/null || true
    rm -f "nginx/proxy_headers.conf" 2>/dev/null || true
    rm -f "nginx/nginx_${HOST:-dev4._4NKweb.com}-https.conf" 2>/dev/null || true
    rm -f "nginx/deploy_configs.sh" 2>/dev/null || true
    rm -f "nginx/"*_https.conf 2>/dev/null || true

    # Créer le répertoire de sortie
    mkdir -p "nginx"

    # Générer tous les fichiers de configuration
    generate_upstreams
    generate_internal_configs
    generate_proxy_headers
    generate_https_configs
    generate_consolidated_https_config
    generate_deploy_script

    echo ""
    echo "✅ GÉNÉRATION TERMINÉE !"
    echo "📁 Configurations générées dans: nginx/"
    echo "🔧 Les configurations utilisent les variables d'environnement"
    echo "📊 Services traités: ${#SERVICES[@]}"
}

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