#!/bin/bash
# /usr/local/bin/nginx-user-config-watcher.sh
# Watcher para configs nginx de usuarios via SFTP
# Detecta cualquier archivo *.conf en /home/USER/html/
# Con notificaciones XMPP a jla@librebits.info
#
# v2 — Análisis CSP post-deploy + humanización de errores nginx (P2.5)
# v3 — Multi-sitio por alumno: mi-nginx-SUFIJO.conf → USER-SUFIJO.qu3v3d0.tech
#       Retrocompatible: mi-nginx.conf (sin sufijo) funciona igual que v2

WATCH_DIR="/home"
LOG="/var/log/nginx-user-configs.log"
MAX_SITES=4

log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" >> "$LOG"
}

# Notificación XMPP (fire and forget)
notify_xmpp() {
    local msg="$1"
    /usr/local/bin/xmpp-notify.py "$msg" >/dev/null 2>&1 &
}

# -------------------------------------------------------
# analyze_csp()  —  Analiza un .conf desplegado buscando
#   cabeceras CSP y de seguridad. Devuelve texto con pistas.
# -------------------------------------------------------
analyze_csp() {
    local conf="$1"
    local hints=""
    local conf_content
    conf_content=$(cat "$conf" 2>/dev/null) || return

    # --- Check 1: ¿Tiene cabecera CSP? ---
    if ! echo "$conf_content" | grep -q "Content-Security-Policy"; then
        hints="${hints}💡 Tu .conf no tiene cabecera Content-Security-Policy (opcional según la práctica)
"
    else
        # --- Check 2: ¿CSP multiline? (add_header ... " sin cierre en misma línea) ---
        # Buscamos líneas con add_header Content-Security-Policy que abren comillas
        # pero no las cierran en la misma línea
        if echo "$conf_content" | grep -E 'add_header\s+Content-Security-Policy' | grep -qE '"[^"]*$'; then
            hints="${hints}⚠️ CSP con saltos de línea: ponlo todo en UNA sola línea entre comillas
"
        fi

        # --- Check 3: ¿CSP en bloque HTTPS (443) o solo en HTTP (80)? ---
        # Estrategia: buscar si CSP aparece ANTES del primer listen 443
        # o si no hay listen 443 en absoluto
        local has_443
        has_443=$(echo "$conf_content" | grep -c "listen.*443")
        if [[ "$has_443" -eq 0 ]]; then
            hints="${hints}⚠️ No hay bloque HTTPS (listen 443) — la CSP debería ir en el bloque HTTPS
"
        else
            # Comprobar si CSP está solo en bloque HTTP (antes de listen 443)
            # Obtenemos la línea de CSP y la línea de listen 443
            local csp_line
            local ssl_line
            csp_line=$(echo "$conf_content" | grep -n "Content-Security-Policy" | head -1 | cut -d: -f1)
            ssl_line=$(echo "$conf_content" | grep -n "listen.*443" | head -1 | cut -d: -f1)
            if [[ -n "$csp_line" && -n "$ssl_line" && "$csp_line" -lt "$ssl_line" ]]; then
                # CSP aparece antes del bloque 443 — verificar si también está después
                local csp_after_ssl
                csp_after_ssl=$(echo "$conf_content" | tail -n +"$ssl_line" | grep -c "Content-Security-Policy")
                if [[ "$csp_after_ssl" -eq 0 ]]; then
                    hints="${hints}⚠️ CSP solo en bloque HTTP (80), no en HTTPS (443) — ponla en el bloque donde se sirve tu web
"
                fi
            fi
        fi

        # --- Check 4: ¿unsafe-inline en script-src? ---
        if echo "$conf_content" | grep -i "script-src" | grep -qi "unsafe-inline"; then
            hints="${hints}⚠️ unsafe-inline en script-src debilita la protección CSP contra XSS
"
        fi

        # --- Check 5: ¿Falta 'always' en add_header CSP? ---
        if echo "$conf_content" | grep "Content-Security-Policy" | grep -qv "always"; then
            hints="${hints}💡 Consejo: añade 'always' para que CSP se envíe también en respuestas 4xx/5xx
"
        fi
    fi

    # --- Check 6: ¿Tiene las otras cabeceras de seguridad? ---
    local missing_headers=""
    if ! echo "$conf_content" | grep -q "X-Content-Type-Options"; then
        missing_headers="${missing_headers} X-Content-Type-Options"
    fi
    if ! echo "$conf_content" | grep -q "X-Frame-Options"; then
        missing_headers="${missing_headers} X-Frame-Options"
    fi
    if ! echo "$conf_content" | grep -q "X-XSS-Protection"; then
        missing_headers="${missing_headers} X-XSS-Protection"
    fi
    if ! echo "$conf_content" | grep -q "Referrer-Policy"; then
        missing_headers="${missing_headers} Referrer-Policy"
    fi
    if [[ -n "$missing_headers" ]]; then
        hints="${hints}💡 Faltan cabeceras de seguridad:${missing_headers}
"
    fi

    # Devolver resultado
    if [[ -z "$hints" ]]; then
        echo "🔒 CSP y cabeceras de seguridad: todo OK"
    else
        echo "$hints"
    fi
}

# -------------------------------------------------------
# humanize_nginx_error()  —  Traduce errores nginx -t
#   a pistas comprensibles para el alumno.
# -------------------------------------------------------
humanize_nginx_error() {
    local error_output="$1"
    local pistas=""

    if echo "$error_output" | grep -q 'unexpected "}"'; then
        pistas="${pistas}💡 ¿Te falta un ';' al final de alguna directiva?
"
    fi
    if echo "$error_output" | grep -q "unexpected end of file"; then
        pistas="${pistas}💡 ¿Cerraste todos los bloques server { } con '}'?
"
    fi
    if echo "$error_output" | grep -q "directive is not allowed"; then
        pistas="${pistas}💡 Revisa que cada directiva esté dentro del bloque server { } correcto
"
    fi
    if echo "$error_output" | grep -q "unknown directive"; then
        pistas="${pistas}💡 ¿Hay algún typo en el nombre de una directiva?
"
    fi
    if echo "$error_output" | grep -q "invalid number of arguments"; then
        pistas="${pistas}💡 Alguna directiva tiene argumentos de más o de menos — revisa comillas y punto y coma
"
    fi
    if echo "$error_output" | grep -qE '(missing|unexpected) ";"'; then
        pistas="${pistas}💡 Revisa los punto y coma (;) — puede que sobre o falte alguno
"
    fi

    echo "$pistas"
}

# -------------------------------------------------------
# check_https_redirect()  —  Verifica si la config tiene
#   redirección HTTP → HTTPS (return 301 https://)
# -------------------------------------------------------
check_https_redirect() {
    local conf="$1"
    local expected_name="$2"
    local conf_content
    conf_content=$(cat "$conf" 2>/dev/null) || return
    local hints=""

    # ¿Tiene listen 443 ssl? (es decir, ¿sirve HTTPS?)
    if echo "$conf_content" | grep -q "listen.*443.*ssl"; then
        # Tiene HTTPS → ¿redirige HTTP a HTTPS?
        if ! echo "$conf_content" | grep -qE "return\s+301\s+https://"; then
            hints="${hints}⚠️ HTTPS activo pero NO hay redirección HTTP → HTTPS.
💡 Añade un bloque server { listen 80; return 301 https://\$server_name\$request_uri; }
"
        else
            hints="${hints}✅ Redirección HTTP → HTTPS configurada correctamente
"
        fi
    else
        # No tiene HTTPS
        hints="${hints}⚠️ Tu config no tiene bloque HTTPS (listen 443 ssl) — el tráfico no va cifrado
💡 Recuerda: la práctica requiere forzar tráfico HTTP → HTTPS
"
    fi

    echo "$hints"
}

# -------------------------------------------------------
# check_naming_convention()  —  Avisa si el fichero .conf
#   no sigue la nomenclatura mi-nginx[-SUFIJO].conf
# -------------------------------------------------------
check_naming_convention() {
    local conffile="$1"
    if [[ ! "$conffile" =~ ^mi-nginx(-[a-z0-9]+)?\.conf$ ]]; then
        echo "📛 Tu fichero se llama '$conffile' — la nomenclatura recomendada es:
   • mi-nginx.conf              → sitio principal
   • mi-nginx-hextris.conf      → segundo sitio (Hextris)
   • mi-nginx-app.conf          → tercer sitio (App)
   Usa el formato mi-nginx-NOMBRE.conf para que el sistema detecte automáticamente tu subdominio.
"
    fi
}

# -------------------------------------------------------
# extract_app_suffix()  —  Extrae el sufijo de app del nombre del .conf
#   mi-nginx.conf         → "" (vacío = sitio principal)
#   mi-nginx-portfolio.conf → "portfolio"
#   otro-nombre.conf      → "" (no sigue el patrón multi-sitio)
# -------------------------------------------------------
extract_app_suffix() {
    local conffile="$1"
    if [[ "$conffile" =~ ^mi-nginx-([a-z0-9]+)\.conf$ ]]; then
        echo "${BASH_REMATCH[1]}"
    else
        echo ""
    fi
}

# -------------------------------------------------------
# undeploy_site()  —  Elimina un site de nginx cuando el
#   alumno borra su mi-nginx[-SUFIJO].conf via SFTP
# -------------------------------------------------------
undeploy_site() {
    local user="$1"
    local conffile="$2"

    local app_suffix
    app_suffix=$(extract_app_suffix "$conffile")

    local site_id
    if [[ -n "$app_suffix" ]]; then
        site_id="${user}-${app_suffix}"
    else
        site_id="${user}"
    fi

    local dest="/etc/nginx/sites-available/$site_id"
    local enabled="/etc/nginx/sites-enabled/$site_id"

    # Solo actuar si el site existe desplegado
    if [[ -f "$dest" || -L "$enabled" ]]; then
        rm -f "$enabled" "$dest"

        # Validar que nginx sigue OK sin ese site
        if nginx -t 2>&1 | grep -q "successful"; then
            systemctl reload nginx
            log "[$user] UNDEPLOY: Site $site_id eliminado (borrado $conffile) y nginx recargado"
            notify_xmpp "🗑️ [$user] Site $site_id eliminado (borrado $conffile)"
        else
            log "[$user] UNDEPLOY: Site $site_id eliminado pero nginx -t falló (recargando de todas formas)"
            systemctl reload nginx
        fi
    fi
}

validate_and_deploy() {
    local user="$1"
    local conffile="$2"
    local src="/home/$user/html/$conffile"

    # --- v3: Determinar sufijo de app y nombres esperados ---
    local app_suffix
    app_suffix=$(extract_app_suffix "$conffile")

    local expected_name
    local expected_root
    local site_id

    if [[ -n "$app_suffix" ]]; then
        expected_name="${user}-${app_suffix}"
        expected_root="/home/$user/html/$app_suffix"
        site_id="${user}-${app_suffix}"
    else
        expected_name="${user}"
        expected_root="/home/$user/html"
        site_id="${user}"
    fi

    local dest="/etc/nginx/sites-available/$site_id"
    local enabled="/etc/nginx/sites-enabled/$site_id"
    local tmp="/tmp/nginx-test-${site_id}.conf"
    local backup="/tmp/nginx-backup-${site_id}.conf"
    local error_file="/home/$user/html/nginx-error.log"
    local status_file="/home/$user/html/nginx-status.log"
    local practica_file="/home/$user/html/practica-status.log"

    # Verificar que el archivo existe
    [[ ! -f "$src" ]] && return 1

    # --- v3: Límite de sitios por alumno (solo para sitios NUEVOS) ---
    if [[ -n "$app_suffix" && ! -f "$dest" ]]; then
        local current_sites
        current_sites=$(ls /etc/nginx/sites-enabled/${user} /etc/nginx/sites-enabled/${user}-* 2>/dev/null | wc -l)
        if (( current_sites >= MAX_SITES )); then
            log "[$user] RECHAZADO: límite de $MAX_SITES sitios alcanzado"
            echo "ERROR: Ya tienes $MAX_SITES sitios desplegados (límite máximo $MAX_SITES)." > "$error_file"
            echo "Elimina algún mi-nginx-*.conf si quieres crear uno nuevo." >> "$error_file"
            chown $user:www-data "$error_file" 2>/dev/null
            notify_xmpp "❌ [$user] Config RECHAZADA: límite de $MAX_SITES sitios alcanzado"
            return 1
        fi
    fi

    # Copiar a temporal para validar
    cp "$src" "$tmp"

    # Comprobar nomenclatura del fichero (aviso temprano)
    local naming_check
    naming_check=$(check_naming_convention "$conffile")

    # SEGURIDAD: Verificar que server_name coincide con el esperado
    if ! grep -qE "^\s*server_name\s+${expected_name}\.(local|qu3v3d0\.tech)" "$tmp"; then
        log "[$user] RECHAZADO: server_name no coincide (esperado: ${expected_name}.qu3v3d0.tech)"
        {
            echo "ERROR: server_name debe ser ${expected_name}.qu3v3d0.tech"
            if [[ -n "$naming_check" ]]; then
                echo ""
                echo "$naming_check"
            fi
        } > "$error_file"
        if [[ -n "$app_suffix" ]]; then
            echo "(Para el fichero $conffile el subdominio esperado es ${expected_name}.qu3v3d0.tech)" >> "$error_file"
        fi
        chown $user:www-data "$error_file" 2>/dev/null
        notify_xmpp "❌ [$user] Config RECHAZADA: server_name incorrecto ($conffile, esperado: ${expected_name})"
        rm -f "$tmp"
        return 1
    fi

    # SEGURIDAD: Verificar que root apunta al directorio correcto
    # - Sin sufijo: prefijo /home/USER/html (v2-compatible, permite subdirectorios)
    # - Con sufijo: exacto /home/USER/html/SUFIJO (multi-sitio v3)
    if [[ -n "$app_suffix" ]]; then
        if ! grep -qE "^\s*root\s+${expected_root}\s*;" "$tmp"; then
            log "[$user] RECHAZADO: root no apunta a $expected_root"
            echo "ERROR: root debe ser ${expected_root}" > "$error_file"
            echo "(Para el fichero $conffile la carpeta debe ser html/$app_suffix/)" >> "$error_file"
            chown $user:www-data "$error_file" 2>/dev/null
            notify_xmpp "❌ [$user] Config RECHAZADA: root incorrecto ($conffile, esperado: ${expected_root})"
            rm -f "$tmp"
            return 1
        fi
    else
        # Retrocompatible con v2: acepta /home/USER/html y cualquier subdirectorio
        if ! grep -qE "^\s*root\s+/home/$user/html" "$tmp"; then
            log "[$user] RECHAZADO: root no apunta a /home/$user/html"
            echo "ERROR: root debe ser /home/$user/html" > "$error_file"
            chown $user:www-data "$error_file" 2>/dev/null
            notify_xmpp "❌ [$user] Config RECHAZADA: root incorrecto ($conffile)"
            rm -f "$tmp"
            return 1
        fi
    fi

    # --- v3: Verificar que el subdirectorio existe (solo multi-sitio) ---
    if [[ -n "$app_suffix" && ! -d "$expected_root" ]]; then
        log "[$user] RECHAZADO: directorio $expected_root no existe"
        echo "ERROR: La carpeta '$app_suffix/' no existe dentro de html/." > "$error_file"
        echo "Crea primero la carpeta via SFTP (FileZilla) y luego vuelve a subir $conffile." >> "$error_file"
        chown $user:www-data "$error_file" 2>/dev/null
        notify_xmpp "❌ [$user] Config RECHAZADA: carpeta html/$app_suffix/ no existe"
        rm -f "$tmp"
        return 1
    fi

    # SEGURIDAD: Bloquear directivas peligrosas (ignorando comentarios)
    if grep -v "^\s*#" "$tmp" | grep -qE "(proxy_pass|fastcgi_pass|uwsgi_pass|include\s+/|lua_|perl_|upstream)" ; then
        log "[$user] RECHAZADO: directivas prohibidas detectadas ($conffile)"
        echo "ERROR: Directivas proxy/include/lua no permitidas" > "$error_file"
        chown $user:www-data "$error_file" 2>/dev/null
        notify_xmpp "❌ [$user] Config RECHAZADA: directivas prohibidas ($conffile)"
        rm -f "$tmp"
        return 1
    fi

    # Hacer backup del config actual si existe
    [[ -f "$dest" ]] && cp "$dest" "$backup"

    # Copiar nuevo config a sites-available
    cp "$tmp" "$dest"

    # Asegurar que el symlink existe
    ln -sf "$dest" "$enabled"

    # Validar sintaxis nginx con la nueva config
    local nginx_output
    nginx_output=$(nginx -t 2>&1)

    if echo "$nginx_output" | grep -q "successful"; then
        # Sintaxis OK - recargar nginx
        systemctl reload nginx
        log "[$user] OK: Config desplegada ($conffile → $site_id) y nginx recargado"

        # Analizar CSP y cabeceras de seguridad
        local csp_analysis
        csp_analysis=$(analyze_csp "$dest")

        # Analizar redirección HTTP → HTTPS
        local https_check
        https_check=$(check_https_redirect "$dest" "$expected_name")

        # Mensaje de deploy según sea sitio principal o sub-sitio
        local deploy_msg
        if [[ -n "$app_suffix" ]]; then
            deploy_msg="✅ [$user] Config desplegada OK ($conffile → ${expected_name}.qu3v3d0.tech)"
        else
            deploy_msg="✅ [$user] Config desplegada OK ($conffile)"
        fi

        # XMPP al profesor (resumen + todos los análisis)
        notify_xmpp "$deploy_msg
$https_check$csp_analysis${naming_check:+
$naming_check}"

        # nginx-status.log (resumen para el alumno)
        {
            echo "OK: Config desplegada desde $conffile $(date)"
            if [[ -n "$app_suffix" ]]; then
                echo "🌐 Sitio: https://${expected_name}.qu3v3d0.tech"
            fi
            echo ""
            echo "$https_check"
            echo "$csp_analysis"
            if [[ -n "$naming_check" ]]; then
                echo "$naming_check"
            fi
        } > "$status_file"
        chown $user:www-data "$status_file" 2>/dev/null

        # practica-status.log (detalle completo)
        {
            echo "=== Análisis de $conffile — $(date) ==="
            if [[ -n "$app_suffix" ]]; then
                echo "🌐 Sitio: https://${expected_name}.qu3v3d0.tech"
                echo "📁 Root: $expected_root"
            fi
            echo ""
            echo "--- Redirección HTTPS ---"
            echo "$https_check"
            echo "--- Seguridad (CSP y cabeceras) ---"
            echo "$csp_analysis"
            if [[ -n "$naming_check" ]]; then
                echo "--- Nomenclatura ---"
                echo "$naming_check"
            fi
            echo "---"
            echo "Revisa el enunciado de tu práctica para los entregables pendientes."
        } > "$practica_file"
        chown $user:www-data "$practica_file" 2>/dev/null

        rm -f "$error_file"
        rm -f "$backup"
    else
        # Error de sintaxis - revertir
        log "[$user] RECHAZADO: Error de sintaxis nginx ($conffile → $site_id)"

        # Humanizar el error
        local pistas
        pistas=$(humanize_nginx_error "$nginx_output")

        # nginx-error.log con error original + pistas
        {
            echo "$nginx_output" | tail -5
            echo "ERROR: Sintaxis nginx inválida."
            if [[ -n "$pistas" ]]; then
                echo ""
                echo "--- Pistas ---"
                echo "$pistas"
            fi
        } > "$error_file"
        chown $user:www-data "$error_file" 2>/dev/null

        # XMPP al profesor con pistas
        if [[ -n "$pistas" ]]; then
            notify_xmpp "❌ [$user] Config RECHAZADA: sintaxis inválida ($conffile)
$pistas"
        else
            notify_xmpp "❌ [$user] Config RECHAZADA: sintaxis inválida ($conffile)"
        fi

        # Restaurar backup si existe
        if [[ -f "$backup" ]]; then
            cp "$backup" "$dest"
            log "[$user] Config anterior de $site_id restaurada"
        else
            rm -f "$dest" "$enabled"
            log "[$user] Config $site_id eliminada (no había backup)"
        fi
        rm -f "$backup"
    fi

    rm -f "$tmp"
}

log "=== Nginx User Config Watcher v3 iniciado (*.conf, multi-sitio) ==="
notify_xmpp "🚀 [zzz] Nginx Config Watcher v3 iniciado (*.conf, multi-sitio)"

# Bucle principal con inotifywait - detecta cualquier *.conf
# v3.1: también detecta delete/moved_from para limpiar sites huérfanos
inotifywait -m -r -e close_write,moved_to,delete,moved_from --format "%e %w%f" "$WATCH_DIR" 2>/dev/null | while read event filepath; do
    # Captura: /home/USER/html/ARCHIVO.conf
    if [[ "$filepath" =~ ^/home/([^/]+)/html/([^/]+.conf)$ ]]; then
        user="${BASH_REMATCH[1]}"
        conffile="${BASH_REMATCH[2]}"
        if [[ "$event" == *DELETE* || "$event" == *MOVED_FROM* ]]; then
            log "[$user] Detectado borrado de $conffile"
            undeploy_site "$user" "$conffile"
        else
            log "[$user] Detectado cambio en $conffile"
            sleep 1  # Esperar a que el archivo esté completo
            validate_and_deploy "$user" "$conffile"
        fi
    fi
done