#!/usr/bin/env bash
# bulk_create_cpanel5.sh - Versión mejorada con soporte JSON y validación de usuarios MySQL
# Crear cuentas cPanel en masa o de forma interactiva con DB y setup
# Compatible con WHM API 1 (createacct)
# Mejoras v5: Validación previa de usuarios MySQL existentes y recuperación de contraseñas
# Uso: sudo ./bulk_create_cpanel5.sh [--json FILE] [--json-url URL] [--interactive] [--verbose] [--dry-run]

set -euo pipefail
IFS=$'\n\t'

LOGFILE="./bulk_create_cpanel.log"
CREATED="./created_accounts.csv"
VERBOSE=0
DRY_RUN=0
CSV_FILE=""
INTERACTIVE=0
JSON_FILE=""
JSON_URL=""
CRED_FILE="/root/credenciales"

# Verificar si jq está instalado
HAS_JQ=false
if command -v jq &> /dev/null; then
    HAS_JQ=true
fi

print_help() {
  cat <<EOF
Uso:
  ./bulk_create_cpanel5.sh [opciones]

Opciones:
  --json FILE       Leer configuración desde archivo JSON local
  --json-url URL    Leer configuración desde URL (GitHub raw, etc.)
  --csv FILE        Leer cuentas desde CSV (domain,username,password,plan,email,quota)
  --interactive     Modo interactivo: pedir datos por consola
  --dry-run         No crea cuentas, solo muestra lo que haría
  --verbose         Muestra toda la salida de whmapi1
  --help            Muestra esta ayuda

Ejemplo con JSON:
  ./bulk_create_cpanel5.sh --json /path/to/mi-proyecto.json
  ./bulk_create_cpanel5.sh --json-url https://raw.githubusercontent.com/user/repo/branch/mi-proyecto.json

Mejoras v5:
  - Validación previa de usuarios MySQL existentes
  - Recuperación automática de contraseñas desde credenciales guardadas
  - Detección y manejo inteligente de conflictos de recursos
EOF
}

log() {
  local msg="$1"
  echo "[$(date +'%F %T')] $msg" | tee -a "$LOGFILE"
}

require_root() {
  if (( EUID != 0 )); then
    echo "❌ Este script debe ejecutarse como root." >&2
    exit 2
  fi
}

gen_password() {
  if command -v openssl >/dev/null 2>&1; then
    openssl rand -base64 12 | tr -d '/+=' | cut -c1-14
  else
    date +%s | sha1sum | cut -c1-14
  fi
}

get_max_username_length() {
  local len
  len=$(grep -E "^MAX_USERNAME_LENGTH=" /var/cpanel/cpanel.config 2>/dev/null | cut -d= -f2)
  len=${len:-8}
  echo "$len"
}

user_exists() {
  local u="$1"
  local result
  result=$(whmapi1 listaccts searchtype=user search="$u" --output=json 2>/dev/null)
  if [[ $? -ne 0 || -z "$result" ]]; then
    [[ $VERBOSE -eq 1 ]] && echo "⚠️  Advertencia: fallo al consultar WHMAPI1 para $u" >&2
    return 1
  fi
  if echo "$result" | grep -q "\"user\": *\"$u\""; then
    return 0
  else
    return 1
  fi
}

read_json_value() {
  local path=$1
  local json_file=$2
  if [ "$HAS_JQ" = true ]; then
    jq -r "$path // empty" "$json_file" 2>/dev/null
  else
    echo ""
  fi
}

download_json() {
  local url=$1
  local temp_file=$(mktemp)
  if command -v curl >/dev/null 2>&1; then
    curl -s -f "$url" -o "$temp_file" || return 1
  elif command -v wget >/dev/null 2>&1; then
    wget -q -O "$temp_file" "$url" || return 1
  else
    echo "❌ Se necesita curl o wget para descargar JSON desde URL" >&2
    return 1
  fi
  echo "$temp_file"
}

setup_ssh_keys() {
  local username="$1"
  local home_dir="/home/$username"
  local ssh_dir="$home_dir/.ssh"
  local root_ssh_dir="/root/.ssh"

  mkdir -p "$ssh_dir"

  local keys=()
  [[ -f "$root_ssh_dir/id_rsa" ]] && keys+=("id_rsa")
  [[ -f "$root_ssh_dir/id_ed25519" ]] && keys+=("id_ed25519")

  if [[ ${#keys[@]} -eq 0 ]]; then
    log "⚠️  No hay claves SSH disponibles en root para copiar."
    return 1
  fi

  echo "🔑 Configurando claves SSH para $username..."
  for key in "${keys[@]}"; do
    cp "$root_ssh_dir/$key" "$ssh_dir/$key"
    cp "$root_ssh_dir/$key.pub" "$ssh_dir/$key.pub"
  done

  cat "$ssh_dir"/*.pub > "$ssh_dir/authorized_keys"

  chown -R "$username:$username" "$ssh_dir"
  chmod 700 "$ssh_dir"
  chmod 600 "$ssh_dir"/*
  chmod 644 "$ssh_dir"/*.pub
  chmod 600 "$ssh_dir/authorized_keys"

  log "✅ Claves SSH (RSA/Ed25519) configuradas para $username"
}

run_as_cpanel_user() {
    local username="$1"
    local cmd="$2"
    su - "$username" -c "$cmd"
}

install_composer() {
    local username="$1"
    local home_dir="/home/$username"
    local composer_dir="$home_dir/.local/bin"
    local composer_bin="$composer_dir/composer"

    # Encontrar PHP CLI
    local php_cli=$(find_php_cli "$username")

    echo "🔍 PHP CLI detectado: $php_cli"
    echo "📁 Directorio Composer: $composer_dir"

    # Crear directorio primero (como root para asegurar permisos)
    mkdir -p "$composer_dir"
    chown "$username:$username" "$composer_dir"

    # Verificar si ya existe
    if [ -f "$composer_bin" ]; then
        echo "✅ Composer ya estaba instalado"
        sudo -u "$username" bash -c "cd $home_dir && $php_cli $composer_bin --version 2>&1" || true
        return 0
    fi

    echo "⚠️ Composer no instalado. Instalando..."

    # Descargar instalador usando wget (no requiere allow_url_fopen)
    sudo -u "$username" bash -c "
        cd $home_dir || exit 1
        wget -q --no-check-certificate https://getcomposer.org/installer -O composer-setup.php 2>&1
    " || {
        echo "❌ Error al descargar instalador de Composer"
        return 1
    }

    # Instalar usando PHP CLI con allow_url_fopen habilitado temporalmente
    # El instalador de Composer necesita allow_url_fopen para validar la descarga
    sudo -u "$username" bash -c "
        cd $home_dir || exit 1
        $php_cli -d allow_url_fopen=On composer-setup.php --install-dir=$composer_dir --filename=composer 2>&1
    " || {
        echo "❌ Error al instalar Composer"
        echo "💡 Intentando con método alternativo..."

        # Método alternativo: descargar directamente el phar de Composer
        sudo -u "$username" bash -c "
            cd $home_dir || exit 1
            wget -q --no-check-certificate https://getcomposer.org/composer-stable.phar -O $composer_bin 2>&1
        " || {
            echo "❌ Error al descargar Composer directamente"
            sudo -u "$username" rm -f "$home_dir/composer-setup.php" 2>/dev/null || true
            return 1
        }

        # Hacer ejecutable
        chmod +x "$composer_bin"
        chown "$username:$username" "$composer_bin"

        # Verificar que funciona usando PHP CLI explícitamente
        if sudo -u "$username" bash -c "$php_cli $composer_bin --version 2>&1" >/dev/null 2>&1; then
            echo "✅ Composer instalado usando método alternativo"
        else
            echo "❌ Composer descargado pero no funciona"
            sudo -u "$username" rm -f "$home_dir/composer-setup.php" 2>/dev/null || true
            return 1
        fi
    }

    # Limpiar instalador
    sudo -u "$username" rm -f "$home_dir/composer-setup.php" 2>/dev/null || true

    # Verificar que se creó
    if [ -f "$composer_bin" ]; then
        chmod +x "$composer_bin"
        chown "$username:$username" "$composer_bin"

        echo "✅ Composer instalado en $composer_bin"

        # Verificar versión usando PHP CLI explícitamente (SIEMPRE)
        # IMPORTANTE: NUNCA ejecutar composer directamente, siempre con php explícito
        echo "Versión de Composer:"
        sudo -u "$username" bash -c "cd $home_dir && $php_cli $composer_bin --version 2>&1" || echo "⚠️  Composer instalado pero no ejecutable"
    else
        echo "❌ Error: Composer no se instaló correctamente"
        return 1
    fi

    # Check fileinfo
    if ! sudo -u "$username" bash -c "$php_cli -m 2>/dev/null | grep -q 'fileinfo'"; then
        echo "❌ Advertencia: fileinfo no habilitada en PHP CLI"
    fi
}

enable_php_extensions() {
  local username="$1"
  echo "⚙️  Revisá que las extensiones PHP necesarias estén habilitadas para $username." >&2
  echo "    En cPanel sería: Select PHP Version -> Extensions -> habilitar fileinfo, etc." >&2
}

find_php_cli() {
  local username="$1"
  local home_dir="/home/$username"

  # Lista de rutas posibles para PHP CLI (orden de prioridad)
  # IMPORTANTE: Priorizar PHP 8.2+ para compatibilidad con Laravel 9.52+
  # cPanel usa /opt/cpanel/ea-php{version}/root/usr/bin/php
  local php_paths=(
    "/opt/cpanel/ea-php82/root/usr/bin/php"  # PHP 8.2 (prioridad 1)
    "/opt/cpanel/ea-php83/root/usr/bin/php"  # PHP 8.3 (prioridad 2)
    "/opt/cpanel/ea-php84/root/usr/bin/php"  # PHP 8.4 (prioridad 3)
    "/opt/cpanel/ea-php81/root/usr/bin/php"  # PHP 8.1 (fallback)
    "/usr/local/bin/php"  # PHP CLI típico en cPanel
    "/opt/cpanel/ea-php*/root/usr/bin/php"  # Cualquier otra versión
    "/usr/bin/php"  # Último recurso (puede ser php-cgi)
  )

  # Buscar PHP CLI verificando que NO sea php-cgi
  for php_path in "${php_paths[@]}"; do
    # Expandir globs si existen
    for expanded_path in $php_path; do
      if [ -x "$expanded_path" ] && [ -f "$expanded_path" ]; then
        # Verificar que el nombre no contenga "cgi"
        if ! echo "$expanded_path" | grep -q "cgi"; then
          # CRÍTICO: Verificar ejecutándolo - php-cgi muestra "(cgi-fcgi)" en -v
          local php_version=$(sudo -u "$username" bash -c "$expanded_path -v 2>&1")
          if echo "$php_version" | grep -q "cgi-fcgi"; then
            continue  # Es php-cgi, saltar
          fi
          # Verificar que NO muestre el mensaje de php-cgi
          if ! echo "$php_version" | grep -q "Usage: php-cgi"; then
            # Verificar que funciona ejecutando código simple
            if sudo -u "$username" bash -c "$expanded_path -r 'echo \"CLI_OK\";' 2>&1" | grep -q "CLI_OK"; then
              echo "$expanded_path"
              return 0
            fi
          fi
        fi
      fi
    done
  done

  # Fallback: buscar como usuario pero verificar que no sea cgi
  local user_php=$(sudo -u "$username" bash -c "which php 2>/dev/null" | head -n 1)
  if [ -n "$user_php" ] && [ -x "$user_php" ]; then
    if ! echo "$user_php" | grep -q "cgi"; then
      # Verificar que no sea php-cgi ejecutándolo
      local php_check=$(sudo -u "$username" bash -c "$user_php -v 2>&1")
      if ! echo "$php_check" | grep -q "cgi-fcgi"; then
        if ! echo "$php_check" | grep -q "Usage: php-cgi"; then
          echo "$user_php"
          return 0
        fi
      fi
    fi
  fi

  # Último fallback: /usr/local/bin/php (esperando que sea CLI)
  echo "/usr/local/bin/php"
}

configure_project_from_json() {
  local username="$1"
  local project_path="$2"
  local json_file="$3"

  if [ "$HAS_JQ" = false ]; then
    echo "⚠️  jq no está instalado. No se puede configurar desde JSON."
    return 1
  fi

  echo "⚙️  Configurando proyecto desde JSON..."

  # Encontrar PHP CLI correcto
  local php_cli=$(find_php_cli "$username")

  # Leer valores del JSON
  local demo=$(read_json_value ".system.demo" "$json_file")

  # Configurar demo en cd-system.php usando sed (más robusto)
  if [ -n "$demo" ] && [ "$demo" != "null" ] && [ -f "$project_path/config/cd-system.php" ]; then
    sudo -u "$username" bash -c "
      cd \"$project_path\" || exit 1
      # Usar sed para cambiar el demo
      sed -i \"s/'demo' => '[^']*'/'demo' => '$demo'/\" config/cd-system.php 2>/dev/null || true
    " && echo "✅ Demo configurado: $demo" || echo "⚠️  No se pudo configurar demo"
  fi

  # Configurar módulos usando sed (simplificado)
  local modules_json=$(read_json_value ".system.modules" "$json_file")
  if [ -n "$modules_json" ] && [ "$modules_json" != "null" ] && [ -f "$project_path/config/cd-system.php" ]; then
    # Para cada módulo en el JSON, activar/desactivar
    echo "$modules_json" | jq -r 'to_entries[] | "\(.key)|\(.value)"' | while IFS='|' read -r module active; do
      if [ "$active" = "true" ]; then
        sudo -u "$username" bash -c "
          cd \"$project_path\" || exit 1
          sed -i \"/'$module' =>/,/'active' =>/ s/'active' => [^,]*/'active' => true/\" config/cd-system.php 2>/dev/null || true
        "
      else
        sudo -u "$username" bash -c "
          cd \"$project_path\" || exit 1
          sed -i \"/'$module' =>/,/'active' =>/ s/'active' => [^,]*/'active' => false/\" config/cd-system.php 2>/dev/null || true
        "
      fi
    done
    echo "✅ Módulos configurados desde JSON"
  fi

  echo "✅ Configuración desde JSON aplicada"
}

generate_env_file() {
  local username="$1"
  local project_path="$2"
  local db_name="$3"
  local db_user="$4"
  local db_pass="$5"
  local site_url="$6"
  local site_name="$7"
  local php_cli="${8:-$(find_php_cli "$username")}"  # Usar parámetro si existe, sino detectar

  echo "⚙️  Generando archivo .env..."
  echo "🔍 PHP CLI para .env: $php_cli"
  echo "🔍 Credenciales a usar: DB=$db_name, USER=$db_user"

  # Usar un método más robusto: crear un script temporal de Python/PHP para actualizar el .env
  # Esto evita problemas con escape de caracteres especiales
  sudo -u "$username" bash -c "
    cd \"$project_path\" || exit 1
    if [ ! -f .env ]; then
      cp .env.example .env
    fi

    # Método robusto: usar awk para actualizar líneas específicas
    # Esto evita problemas con caracteres especiales en contraseñas
    awk -v db_name=\"$db_name\" \
        -v db_user=\"$db_user\" \
        -v db_pass=\"$db_pass\" \
        -v site_name=\"$site_name\" \
        -v site_url=\"$site_url\" \
        '
    /^APP_NAME=/ { \$0=\"APP_NAME=\\\"\" site_name \"\\\"\"; }
    /^APP_URL=/ { \$0=\"APP_URL=\" site_url; }
    /^DB_DATABASE=/ { \$0=\"DB_DATABASE=\" db_name; }
    /^DB_USERNAME=/ { \$0=\"DB_USERNAME=\" db_user; }
    /^DB_PASSWORD=/ { \$0=\"DB_PASSWORD=\" db_pass; }
    { print; }
    ' .env > .env.tmp && mv .env.tmp .env

    # Verificar que se actualizó correctamente
    if ! grep -q \"^DB_DATABASE=$db_name$\" .env; then
      echo \"⚠️  Advertencia: DB_DATABASE no se actualizó correctamente\" >&2
    fi
    if ! grep -q \"^DB_USERNAME=$db_user$\" .env; then
      echo \"⚠️  Advertencia: DB_USERNAME no se actualizó correctamente\" >&2
    fi
    if ! grep -q \"^DB_PASSWORD=$db_pass$\" .env; then
      echo \"⚠️  Advertencia: DB_PASSWORD no se actualizó correctamente\" >&2
      echo \"   Contraseña esperada: $db_pass\" >&2
      echo \"   Contraseña en .env: \$(grep '^DB_PASSWORD=' .env | cut -d= -f2)\" >&2
    fi

    # Generar APP_KEY si no existe
    if ! grep -q 'APP_KEY=' .env || grep -q 'APP_KEY=\$' .env || [ -z \"\$(grep '^APP_KEY=' .env | cut -d= -f2 | tr -d ' ')\" ]; then
      $php_cli artisan key:generate --force 2>/dev/null || true
    fi
  "

  # Verificar que el .env se actualizó correctamente
  local env_check_db
  local env_check_user
  local env_check_pass

  env_check_db=$(sudo -u "$username" bash -c "
    cd \"$project_path\" || exit 1
    grep '^DB_DATABASE=' .env | cut -d= -f2
  " 2>/dev/null)

  env_check_user=$(sudo -u "$username" bash -c "
    cd \"$project_path\" || exit 1
    grep '^DB_USERNAME=' .env | cut -d= -f2
  " 2>/dev/null)

  env_check_pass=$(sudo -u "$username" bash -c "
    cd \"$project_path\" || exit 1
    grep '^DB_PASSWORD=' .env | cut -d= -f2
  " 2>/dev/null)

  local all_ok=1

  if [ "$env_check_db" != "$db_name" ]; then
    echo "❌ ERROR: DB_DATABASE no coincide en .env" >&2
    echo "   Esperado: $db_name" >&2
    echo "   Encontrado: $env_check_db" >&2
    all_ok=0
  fi

  if [ "$env_check_user" != "$db_user" ]; then
    echo "❌ ERROR: DB_USERNAME no coincide en .env" >&2
    echo "   Esperado: $db_user" >&2
    echo "   Encontrado: $env_check_user" >&2
    all_ok=0
  fi

  if [ "$env_check_pass" != "$db_pass" ]; then
    echo "❌ ERROR: DB_PASSWORD no coincide en .env" >&2
    echo "   Esperado: $db_pass (${#db_pass} caracteres)" >&2
    echo "   Encontrado: ${env_check_pass:0:20}... (${#env_check_pass} caracteres)" >&2
    all_ok=0
  fi

  if [ $all_ok -eq 1 ]; then
    echo "✅ Archivo .env generado y configurado correctamente"
    echo "   DB_DATABASE=$db_name"
    echo "   DB_USERNAME=$db_user"
    echo "   DB_PASSWORD=${db_pass:0:10}... (${#db_pass} caracteres)"
  else
    echo "❌ ERROR CRÍTICO: El .env NO se actualizó correctamente" >&2
    echo "   Por favor, verifica manualmente el archivo .env" >&2
    return 1
  fi
}

create_public_html_htaccess() {
  local username="$1"
  local repo_name="$2"
  local home_dir="/home/$username"
  local public_html="$home_dir/public_html"

  # Detectar versión PHP para el handler
  local php_cli=$(find_php_cli "$username")
  local php_version="82"  # Default PHP 8.2

  # Extraer versión de PHP del path (ej: /opt/cpanel/ea-php82/root/usr/bin/php -> 82)
  if [[ "$php_cli" =~ ea-php([0-9]+) ]]; then
    php_version="${BASH_REMATCH[1]}"
  fi

  echo "📝 Generando .htaccess en public_html para redirigir a $repo_name/public/..."

  # Crear .htaccess siguiendo el patrón del ejemplo
  # Patrón: RewriteCond %{REQUEST_URI} !^public
  # Esto evita reescribir si ya está accediendo a public, y redirige todo lo demás
  sudo -u "$username" bash -c "
    cat > \"$public_html/.htaccess\" <<HTACCESS_EOF
<IfModule mod_rewrite.c>
    RewriteEngine On

    # Evitar reescribir si la petición ya está en public
    RewriteCond %{REQUEST_URI} !^/$repo_name/public

    # Redirigir todo a la carpeta public de Laravel
    RewriteRule ^(.*)$ $repo_name/public/\\\$1 [L]
</IfModule>

# php -- BEGIN cPanel-generated handler, do not edit
# Set the \"ea-php$php_version\" package as the default \"PHP\" programming language.
<IfModule mime_module>
  AddHandler application/x-httpd-ea-php$php_version .php .php8 .phtml
</IfModule>
# php -- END cPanel-generated handler, do not edit
HTACCESS_EOF
  "

  echo "✅ .htaccess generado en $public_html/.htaccess"
}

setup_ssl_for_domain() {
  local username="$1"
  local domain="$2"

  echo "🔒 Configurando SSL para $domain..."

  # Intentar activar AutoSSL para el dominio
  # AutoSSL es el sistema automático de cPanel que genera certificados Let's Encrypt
  uapi --user="$username" SSL install_ssl_for_domain domain="$domain" 2>/dev/null || {
    echo "⚠️  No se pudo instalar SSL automáticamente. AutoSSL se activará automáticamente en las próximas horas."
    echo "💡 Puedes activarlo manualmente desde cPanel: SSL/TLS Status -> Run AutoSSL"
  }

  # Verificar si AutoSSL está habilitado globalmente
  local autossl_enabled=$(whmapi1 get_tweaksetting key=autossl_provider 2>/dev/null | grep -o "value:.*" | cut -d: -f2 | tr -d ' ')

  if [ -n "$autossl_enabled" ] && [ "$autossl_enabled" != "none" ]; then
    echo "✅ AutoSSL está habilitado. El certificado se generará automáticamente."
  else
    echo "⚠️  AutoSSL no está habilitado. El certificado SSL se generará automáticamente cuando AutoSSL se ejecute."
    echo "💡 Para habilitar AutoSSL: WHM -> SSL/TLS Status -> Run AutoSSL"
  fi

  echo "📝 Nota: Los certificados SSL pueden tardar hasta 24 horas en generarse automáticamente."
  echo "💡 Acceso temporal: Puedes usar HTTP temporalmente: http://$domain"
}

convert_https_to_ssh() {
  local url="$1"
  # Convertir https://github.com/user/repo.git a git@github.com:user/repo.git
  if [[ "$url" =~ ^https://github.com/(.+)$ ]]; then
    echo "git@github.com:${BASH_REMATCH[1]}"
  else
    echo "$url"
  fi
}

clone_repo_in_public_html() {
  local username="$1"
  local repo_url="$2"
  local branch_name="$3"
  local json_file="$4"
  local db_creds="${5:-}"  # Credenciales de BD en formato "db_name|db_user|db_pass"
  local home_dir="/home/$username"
  local public_html="$home_dir/public_html"

  # Encontrar PHP CLI correcto
  local php_cli=$(find_php_cli "$username")

  # Convertir HTTPS a SSH si es necesario
  local ssh_url
  if [[ "$repo_url" =~ ^https:// ]]; then
    ssh_url=$(convert_https_to_ssh "$repo_url")
    echo "🔄 Convirtiendo URL HTTPS a SSH: $ssh_url"
  else
    ssh_url="$repo_url"
  fi

  local repo_name
  repo_name=$(basename "$repo_url" .git)
  local repo_path="$public_html/$repo_name"

  echo "📂 Clonando $ssh_url dentro de $repo_path ..."
  sudo -u "$username" bash -c "
    mkdir -p \"$public_html\"
    cd \"$public_html\" || exit 1
    if [ -d \"$repo_path/.git\" ]; then
      echo '⚠️  El repositorio ya existe, saltando clonación.'
    else
      # Usar SSH con las claves configuradas
      GIT_SSH_COMMAND='ssh -o StrictHostKeyChecking=no' git clone \"$ssh_url\" \"$repo_name\" || exit 1
    fi
  "
  [[ $? -ne 0 ]] && { echo "❌ Error al clonar el repositorio."; return 1; }
  echo "✅ Repositorio clonado correctamente en $repo_path"

  sudo -u "$username" bash -c "
    cd \"$repo_path\" || exit 1
    if git rev-parse --verify \"$branch_name\" >/dev/null 2>&1; then
      git checkout \"$branch_name\"
    else
      git fetch --all
      git checkout -b \"$branch_name\" \"origin/$branch_name\" || true
    fi
  "

  # Generar .htaccess en public_html para redirigir a public/
  create_public_html_htaccess "$username" "$repo_name"

  # Configurar desde JSON si está disponible
  if [ -n "$json_file" ] && [ -f "$json_file" ]; then
    configure_project_from_json "$username" "$repo_path" "$json_file"
  fi

  # Configurar SSL/AutoSSL para el dominio (después de configurar el proyecto)
  if [ -n "$domain" ]; then
    setup_ssl_for_domain "$username" "$domain"
  fi

  echo "🚀 Ejecutando setup completo..."
  enable_php_extensions "$username"

  # Detectar PHP CLI antes de usarlo
  local php_cli=$(find_php_cli "$username")
  echo "🔍 PHP CLI para setup: $php_cli"

  install_composer "$username"

  local setup_script="$repo_path/scripts/setup_cd_project.sh"
  if sudo -u "$username" test -f "$setup_script"; then
    echo "🚀 Ejecutando $setup_script ..."

    # Obtener credenciales de BD que se acaban de crear (si existen)
    local db_name=""
    local db_user=""
    local db_pass=""

    # Prioridad 1: Usar credenciales pasadas como parámetro (de create_mysql_for_new_cpanel_user)
    if [ -n "$db_creds" ] && [[ "$db_creds" =~ \| ]]; then
      db_name=$(echo "$db_creds" | cut -d'|' -f1)
      db_user=$(echo "$db_creds" | cut -d'|' -f2)
      db_pass=$(echo "$db_creds" | cut -d'|' -f3)
      echo "✅ Usando credenciales BD recién creadas"
    fi

    # Prioridad 2: Intentar obtener de credenciales guardadas (última línea del usuario)
    if [ -z "$db_name" ] || [ -z "$db_user" ] || [ -z "$db_pass" ]; then
      if [ -f "$CRED_FILE" ]; then
        local cred_line=$(grep -A 3 "Cuenta cPanel: $username" "$CRED_FILE" | tail -n 3)
        if [ -n "$cred_line" ]; then
          db_name=$(echo "$cred_line" | grep "Base de datos:" | cut -d: -f2 | tr -d ' ')
          db_user=$(echo "$cred_line" | grep "Usuario DB:" | cut -d: -f2 | tr -d ' ')
          db_pass=$(echo "$cred_line" | grep "Contraseña DB:" | cut -d: -f2 | tr -d ' ')
        fi
      fi
    fi

    # Prioridad 3: Leer del JSON o generar
    if [ -z "$db_name" ] || [ -z "$db_user" ] || [ -z "$db_pass" ]; then
      db_name=$(read_json_value ".project.database.name" "$json_file")
      db_user=$(read_json_value ".project.database.username" "$json_file")
      db_pass=$(read_json_value ".project.database.password" "$json_file")
    fi

    # Si no hay valores, usar valores por defecto
    if [ -z "$db_name" ] || [ "$db_name" = "null" ]; then
      db_name="${username}_db"
    fi
    if [ -z "$db_user" ] || [ "$db_user" = "null" ]; then
      db_user="${username}_usr"
    fi
    if [ -z "$db_pass" ] || [ "$db_pass" = "null" ]; then
      db_pass=$(gen_password)
    fi

    local site_url=$(read_json_value ".identity.site_url" "$json_file")
    local site_name=$(read_json_value ".identity.site_name" "$json_file")
    if [ -z "$site_url" ] || [ "$site_url" = "null" ]; then
      site_url="https://${username}.bewpro.com"
    fi
    if [ -z "$site_name" ] || [ "$site_name" = "null" ]; then
      site_name="$username"
    fi

    echo "🔍 Usando credenciales BD: $db_name / $db_user"
    # Generar .env automáticamente
    generate_env_file "$username" "$repo_path" "$db_name" "$db_user" "$db_pass" "$site_url" "$site_name" "$php_cli"

    # Esperar un momento para que MySQL procese los cambios del usuario recién creado
    echo "⏳ Esperando que MySQL procese los cambios del usuario..."
    sleep 5

    # Verificar que las credenciales funcionan antes de continuar (método más simple y rápido)
    echo "🔍 Verificando conexión a base de datos..."
    local db_check_result
    # Usar timeout para evitar que se cuelgue, y método más directo
    db_check_result=$(timeout 10 sudo -u "$username" bash -c "
      cd \"$repo_path\" || exit 1
      # Verificar directamente con mysql client si está disponible, o usar PHP simple
      if command -v mysql >/dev/null 2>&1; then
        mysql -u\"$db_user\" -p\"$db_pass\" -h localhost \"$db_name\" -e 'SELECT 1' 2>&1 | head -1
      else
        # Fallback: usar PHP simple para verificar conexión
        $php_cli -r \"
          try {
            \$pdo = new PDO('mysql:host=localhost;dbname=$db_name', '$db_user', '$db_pass');
            echo 'OK';
          } catch (Exception \$e) {
            echo 'ERROR: ' . \$e->getMessage();
          }
        \" 2>&1
      fi
    " 2>&1) || db_check_result="TIMEOUT"

    if echo "$db_check_result" | grep -qi "access denied\|authentication\|1045\|SQLSTATE\[HY000\]\|ERROR"; then
      echo "⚠️  Advertencia: No se pudo verificar la conexión a BD inmediatamente" >&2
      echo "   BD: $db_name | Usuario: $db_user" >&2
      echo "   Esto puede ser normal si MySQL aún está procesando los cambios" >&2
      echo "   El script continuará y las migraciones verificarán la conexión" >&2
    elif echo "$db_check_result" | grep -qi "OK\|1"; then
      echo "✅ Conexión a BD verificada correctamente"
    elif [ "$db_check_result" = "TIMEOUT" ]; then
      echo "⚠️  La verificación de conexión tomó demasiado tiempo, continuando..." >&2
    else
      echo "⚠️  No se pudo verificar la conexión (resultado: ${db_check_result:0:50}...), pero continuando..."
    fi

    # Ejecutar setup
    local composer_bin="/home/$username/.local/bin/composer"
    sudo -u "$username" bash -c "
      export PATH=\$HOME/.local/bin:\$PATH
      cd \"$repo_path\" || exit 1

      # Limpiar cache de configuración antes de continuar (importante para que Laravel lea el .env actualizado)
      echo '🧹 Limpiando cache de Laravel...'
      $php_cli artisan config:clear 2>/dev/null || true
      $php_cli artisan cache:clear 2>/dev/null || true

      # Verificar que composer existe
      if [ -f $composer_bin ]; then
        # Ejecutar composer usando PHP CLI explícitamente (evita php-cgi)
        # Usar --ignore-platform-reqs para evitar problemas con extensiones y versiones PHP
        echo '⚠️  Usando --ignore-platform-reqs para instalar dependencias...'
        bash -c \"$php_cli $composer_bin install --no-interaction --ignore-platform-reqs\" || true
      else
        echo '❌ Composer no encontrado en $composer_bin'
        exit 1
      fi

      # Esperar un momento adicional para que MySQL esté completamente listo
      sleep 2

      # Ejecutar comandos artisan
      echo '🔄 Ejecutando migraciones...'
      bash -c \"$php_cli artisan migrate:fresh --seed --force\" || {
        echo '❌ Error en migraciones. Verificando credenciales...'
        # Mostrar las credenciales actuales en .env para debugging
        grep -E '^DB_' .env | sed 's/PASSWORD=.*/PASSWORD=***/' || true
        exit 1
      }
      bash -c \"$php_cli artisan storage:link\" || true
    "
    echo "✅ Setup ejecutado correctamente."
  else
    echo "❌ No se encontró el script en $setup_script"
  fi
}

# Función para verificar si un usuario MySQL existe
# Verifica primero desde cPanel API, y si falla, verifica directamente en MySQL
mysql_user_exists() {
  local cpanel_user="$1"
  local db_user="$2"

  # Método 1: Intentar verificar desde cPanel API (solo si el usuario cPanel existe)
  if user_exists "$cpanel_user"; then
    local users_json
    users_json=$(uapi --user="$cpanel_user" Mysql list_users --output=json 2>/dev/null)

    if [ $? -eq 0 ] && [ -n "$users_json" ]; then
      # Verificar si jq está disponible para parsear JSON
      if [ "$HAS_JQ" = true ]; then
        local users
        users=$(echo "$users_json" | jq -r '.data[]?.user // empty' 2>/dev/null)
        # Buscar el usuario exacto o con prefijo del cPanel user
        if echo "$users" | grep -qE "^${db_user}$|^${cpanel_user}_${db_user}$"; then
          return 0
        fi
      else
        # Fallback: buscar en texto plano (con o sin prefijo)
        if echo "$users_json" | grep -qE "\"user\": *\"(${db_user}|${cpanel_user}_${db_user})\""; then
          return 0
        fi
      fi
    fi
  fi

  # Método 2: Verificar directamente en MySQL (fallback cuando el usuario cPanel no existe)
  # Esto es útil cuando el usuario cPanel fue eliminado pero el usuario MySQL sigue existiendo
  if command -v mysql >/dev/null 2>&1; then
    # Buscar el usuario en MySQL directamente (como root)
    # Escapar caracteres especiales para evitar problemas con SQL
    local mysql_users
    mysql_users=$(mysql -e "SELECT User FROM mysql.user WHERE (User = '${db_user}' OR User = '${cpanel_user}_${db_user}') AND Host='localhost';" 2>/dev/null | grep -v "^User$" | grep -E "^${db_user}$|^${cpanel_user}_${db_user}$")

    if [ -n "$mysql_users" ]; then
      return 0
    fi
  fi

  return 1
}

# Función para obtener contraseña de usuario MySQL desde credenciales guardadas
get_existing_mysql_password() {
  local cpanel_user="$1"
  local db_user="$2"

  # Intentar leer desde credenciales guardadas
  if [ -f "$CRED_FILE" ]; then
    # Buscar la sección del usuario cPanel
    local in_section=0
    local found_user=0
    local found_db_user=0
    local password=""

    while IFS= read -r line; do
      # Detectar inicio de sección del usuario
      if echo "$line" | grep -q "Cuenta cPanel: $cpanel_user"; then
        in_section=1
        found_user=1
        continue
      fi

      # Si estamos en la sección correcta
      if [ $in_section -eq 1 ]; then
        # Detectar si encontramos el usuario DB correcto
        if echo "$line" | grep -q "Usuario DB: $db_user"; then
          found_db_user=1
          continue
        fi

        # Si encontramos el usuario DB, la siguiente línea con "Contraseña DB:" es la que buscamos
        if [ $found_db_user -eq 1 ] && echo "$line" | grep -q "Contraseña DB:"; then
          password=$(echo "$line" | cut -d: -f2- | sed 's/^ *//')
          # Validar que la contraseña no esté corrupta (más de 50 caracteres es sospechoso)
          if [ ${#password} -le 50 ]; then
            echo "$password"
            return 0
          else
            echo "⚠️  Contraseña corrupta detectada (${#password} caracteres), ignorando..." >&2
            return 1
          fi
        fi

        # Si encontramos otra sección de usuario, salir
        if echo "$line" | grep -q "Cuenta cPanel:"; then
          break
        fi
      fi
    done < "$CRED_FILE"
  fi

  # Si no se encuentra, retornar vacío
  echo ""
  return 1
}

# Función para resetear contraseña de usuario MySQL directamente desde MySQL
# Útil cuando el usuario cPanel no existe pero el usuario MySQL sí
reset_mysql_password_directly() {
  local db_user="$1"
  local new_password="$2"

  if ! command -v mysql >/dev/null 2>&1; then
    echo "❌ mysql client no está disponible para resetear contraseña" >&2
    return 1
  fi

  # Intentar resetear usando ALTER USER (MySQL 5.7+)
  local reset_result
  reset_result=$(mysql -e "ALTER USER '${db_user}'@'localhost' IDENTIFIED BY '${new_password}';" 2>&1)

  if [ $? -eq 0 ]; then
    echo "✅ Contraseña reseteada exitosamente desde MySQL" >&2
    return 0
  fi

  # Si falla, intentar con FLUSH PRIVILEGES después
  if echo "$reset_result" | grep -qi "flush"; then
    mysql -e "FLUSH PRIVILEGES;" 2>/dev/null
    reset_result=$(mysql -e "ALTER USER '${db_user}'@'localhost' IDENTIFIED BY '${new_password}';" 2>&1)
    if [ $? -eq 0 ]; then
      echo "✅ Contraseña reseteada exitosamente desde MySQL (con FLUSH PRIVILEGES)" >&2
      return 0
    fi
  fi

  echo "❌ Error al resetear contraseña desde MySQL: $reset_result" >&2
  return 1
}

# Función para obtener el nombre real del usuario MySQL desde MySQL directamente
get_mysql_user_name_directly() {
  local cpanel_user="$1"
  local db_user="$2"

  if ! command -v mysql >/dev/null 2>&1; then
    echo ""
    return 1
  fi

  # Buscar el usuario en MySQL directamente
  local mysql_user
  mysql_user=$(mysql -e "SELECT User FROM mysql.user WHERE User IN ('${db_user}', '${cpanel_user}_${db_user}') AND Host='localhost';" 2>/dev/null | grep -v "^User$" | head -1)

  if [ -n "$mysql_user" ]; then
    echo "$mysql_user"
    return 0
  fi

  echo ""
  return 1
}

create_mysql_for_new_cpanel_user() {
  local cpanel_user="$1"
  local json_file="$2"

  # Leer valores del JSON o usar defaults
  local db_name=$(read_json_value ".project.database.name" "$json_file")
  local db_user=$(read_json_value ".project.database.username" "$json_file")
  local db_pass=$(read_json_value ".project.database.password" "$json_file")

  # Valores por defecto si no están en JSON
  db_name=${db_name:-"${cpanel_user}_db"}
  db_user=${db_user:-"${cpanel_user}_usr"}
  db_pass=${db_pass:-$(gen_password)}

  # Si los valores son "null" (jq devuelve null), usar defaults
  if [ "$db_name" = "null" ] || [ -z "$db_name" ]; then
    db_name="${cpanel_user}_db"
  fi
  if [ "$db_user" = "null" ] || [ -z "$db_user" ]; then
    db_user="${cpanel_user}_usr"
  fi
  if [ "$db_pass" = "null" ] || [ -z "$db_pass" ]; then
    db_pass=$(gen_password)
  fi

  echo "🔍 Creando base de datos y usuario MySQL para $cpanel_user ..." >&2

  # Verificar si el usuario cPanel existe
  local cpanel_user_exists=0
  if user_exists "$cpanel_user"; then
    cpanel_user_exists=1
  else
    echo "⚠️  El usuario cPanel $cpanel_user no existe (puede haber sido eliminado)" >&2
    echo "   Continuando con verificación directa en MySQL..." >&2
  fi

  # Crear base de datos con mejor manejo de errores
  if [ "$cpanel_user_exists" -eq 1 ]; then
    # Usar cPanel API si el usuario existe
    local db_result
    db_result=$(uapi --user="$cpanel_user" Mysql create_database name="$db_name" 2>&1)
    if [ $? -ne 0 ]; then
      echo "❌ Error al crear la base de datos $db_name" >&2
      echo "   Detalles: $db_result" >&2
      # Verificar si la BD ya existe
      if echo "$db_result" | grep -qi "already exists\|duplicate"; then
        echo "⚠️  La base de datos $db_name ya existe, continuando..." >&2
      else
        return 1
      fi
    fi
  else
    # Si el usuario cPanel no existe, crear la BD directamente desde MySQL
    if command -v mysql >/dev/null 2>&1; then
      local db_exists
      db_exists=$(mysql -e "SHOW DATABASES LIKE '${db_name}';" 2>/dev/null | grep -c "^${db_name}$")
      if [ "$db_exists" -eq 0 ]; then
        mysql -e "CREATE DATABASE \`${db_name}\`;" 2>&1
        if [ $? -eq 0 ]; then
          echo "✅ Base de datos $db_name creada directamente desde MySQL" >&2
        else
          echo "❌ Error al crear la base de datos $db_name desde MySQL" >&2
          return 1
        fi
      else
        echo "⚠️  La base de datos $db_name ya existe, continuando..." >&2
      fi
    else
      echo "❌ No se puede crear la base de datos: usuario cPanel no existe y mysql client no disponible" >&2
      return 1
    fi
  fi

  # VALIDACIÓN CRÍTICA: Verificar si el usuario MySQL ya existe ANTES de intentar crearlo
  echo "🔍 Verificando si el usuario MySQL '$db_user' ya existe..." >&2
  if mysql_user_exists "$cpanel_user" "$db_user"; then
    echo "✅ El usuario MySQL '$db_user' YA EXISTE - NO se creará uno nuevo" >&2

    # Obtener el nombre real del usuario MySQL (puede tener prefijo)
    local actual_mysql_user
    if [ "$cpanel_user_exists" -eq 1 ]; then
      # Si el usuario cPanel existe, intentar obtener desde cPanel API
      if [ "$HAS_JQ" = true ]; then
        actual_mysql_user=$(uapi --user="$cpanel_user" Mysql list_users --output=json 2>/dev/null | \
          jq -r ".data[]?.user // empty" 2>/dev/null | \
          grep -E "^${cpanel_user}_${db_user}$|^${db_user}$" | head -1)
      fi
    fi

    # Si no se encontró desde cPanel API, buscar directamente en MySQL
    if [ -z "$actual_mysql_user" ]; then
      actual_mysql_user=$(get_mysql_user_name_directly "$cpanel_user" "$db_user")
    fi

    # Usar el nombre real encontrado o el proporcionado
    if [ -n "$actual_mysql_user" ]; then
      db_user="$actual_mysql_user"
      echo "   Usuario MySQL real encontrado: '$db_user'" >&2
    fi

    echo "🔍 Intentando obtener contraseña existente desde credenciales guardadas..." >&2

    # Intentar obtener contraseña de credenciales guardadas
    local existing_pass=$(get_existing_mysql_password "$cpanel_user" "$db_user")

    if [ -n "$existing_pass" ]; then
      echo "✅ Contraseña encontrada en credenciales guardadas. Usando contraseña existente." >&2
      db_pass="$existing_pass"

      # Verificar que la contraseña funciona
      if command -v mysql >/dev/null 2>&1; then
        local test_result
        test_result=$(mysql -u"$db_user" -p"$db_pass" -h localhost "$db_name" -e "SELECT 1" 2>&1)
        if [ $? -ne 0 ]; then
          echo "⚠️  La contraseña guardada no funciona. Reseteando contraseña..." >&2
          if reset_mysql_password_directly "$db_user" "$db_pass"; then
            echo "✅ Contraseña reseteada exitosamente" >&2
          else
            echo "❌ No se pudo resetear la contraseña. Generando nueva..." >&2
            db_pass=$(gen_password)
            if reset_mysql_password_directly "$db_user" "$db_pass"; then
              echo "✅ Nueva contraseña generada y aplicada" >&2
              # Actualizar credenciales guardadas con la nueva contraseña
              if [ -f "$CRED_FILE" ]; then
                # Eliminar entrada antigua si existe
                sed -i "/Cuenta cPanel: $cpanel_user/,/^$/d" "$CRED_FILE" 2>/dev/null || true
              fi
              # Agregar nueva entrada
              {
                echo "Cuenta cPanel: $cpanel_user"
                echo "Base de datos: $db_name"
                echo "Usuario DB: $db_user"
                echo "Contraseña DB: $db_pass"
              } >> "$CRED_FILE"
            else
              echo "❌ ERROR: No se pudo resetear la contraseña del usuario MySQL existente" >&2
              return 1
            fi
          fi
        fi
      fi
    else
      # No se encontró contraseña guardada
      if [ "$cpanel_user_exists" -eq 0 ]; then
        # Si el usuario cPanel no existe, podemos resetear la contraseña directamente desde MySQL
        echo "⚠️  Usuario cPanel no existe pero usuario MySQL sí. Reseteando contraseña desde MySQL..." >&2
        if reset_mysql_password_directly "$db_user" "$db_pass"; then
          echo "✅ Contraseña reseteada exitosamente desde MySQL" >&2
          # Actualizar credenciales guardadas con la nueva contraseña
          if [ -f "$CRED_FILE" ]; then
            # Eliminar entrada antigua si existe
            sed -i "/Cuenta cPanel: $cpanel_user/,/^$/d" "$CRED_FILE" 2>/dev/null || true
          fi
          # Agregar nueva entrada
          {
            echo "Cuenta cPanel: $cpanel_user"
            echo "Base de datos: $db_name"
            echo "Usuario DB: $db_user"
            echo "Contraseña DB: $db_pass"
          } >> "$CRED_FILE"
        else
          echo "❌ ERROR: No se pudo resetear la contraseña del usuario MySQL existente" >&2
          echo "" >&2
          echo "💡 SOLUCIÓN: Elimina el usuario MySQL manualmente:" >&2
          echo "   mysql -e \"DROP USER '${db_user}'@'localhost';\"" >&2
          echo "" >&2
          echo "   O usa otro nombre de usuario en el JSON (project.database.username)" >&2
          return 1
        fi
      else
        echo "❌ ERROR CRÍTICO: Usuario MySQL '$db_user' ya existe pero NO se encontró su contraseña en credenciales guardadas." >&2
        echo "" >&2
        echo "💡 SOLUCIÓN: Tienes dos opciones:" >&2
        echo "   1. Eliminar el usuario MySQL existente:" >&2
        echo "      uapi --user=$cpanel_user Mysql delete_user name=$db_user" >&2
        echo "" >&2
        echo "   2. O usar otro nombre de usuario en el JSON (project.database.username)" >&2
        echo "" >&2
        echo "⚠️  El proceso se detiene aquí para evitar errores de autenticación." >&2
        return 1
      fi
    fi
  else
    # El usuario NO existe, crearlo
    echo "ℹ️  El usuario MySQL '$db_user' NO existe - CREÁNDOLO ahora..." >&2
    if [ "$cpanel_user_exists" -eq 1 ]; then
      # Usar cPanel API si el usuario existe
      local user_result
      user_result=$(uapi --user="$cpanel_user" Mysql create_user name="$db_user" password="$db_pass" 2>&1)
      if [ $? -ne 0 ]; then
        echo "❌ Error al crear el usuario $db_user" >&2
        echo "   Detalles: $user_result" >&2
        # Verificar si el error es porque el usuario ya existe
        if echo "$user_result" | grep -qi "already exists\|duplicate\|exists"; then
          echo "⚠️  El usuario ya existe según cPanel API. Intentando usar el existente..." >&2
          # Intentar obtener el nombre real del usuario
          local actual_mysql_user
          if [ "$HAS_JQ" = true ]; then
            actual_mysql_user=$(uapi --user="$cpanel_user" Mysql list_users --output=json 2>/dev/null | \
              jq -r ".data[]?.user // empty" 2>/dev/null | \
              grep -E "^${cpanel_user}_${db_user}$|^${db_user}$" | head -1)
          fi
          if [ -n "$actual_mysql_user" ]; then
            db_user="$actual_mysql_user"
            echo "   Usando usuario existente: '$db_user'" >&2
            # Intentar obtener contraseña guardada
            local existing_pass=$(get_existing_mysql_password "$cpanel_user" "$db_user")
            if [ -n "$existing_pass" ]; then
              db_pass="$existing_pass"
              echo "   Usando contraseña guardada para usuario existente" >&2
            else
              echo "⚠️  No se encontró contraseña guardada. Reseteando..." >&2
              if ! reset_mysql_password_directly "$db_user" "$db_pass"; then
                return 1
              fi
            fi
          else
            return 1
          fi
        else
          return 1
        fi
      else
        echo "✅ Usuario MySQL '$db_user' creado exitosamente" >&2
      fi
    else
      # Si el usuario cPanel no existe, crear el usuario MySQL directamente
      if command -v mysql >/dev/null 2>&1; then
        mysql -e "CREATE USER '${db_user}'@'localhost' IDENTIFIED BY '${db_pass}';" 2>&1
        if [ $? -eq 0 ]; then
          echo "✅ Usuario MySQL '$db_user' creado exitosamente desde MySQL" >&2
        else
          echo "❌ Error al crear el usuario MySQL $db_user desde MySQL" >&2
          return 1
        fi
      else
        echo "❌ No se puede crear el usuario MySQL: usuario cPanel no existe y mysql client no disponible" >&2
        return 1
      fi
    fi

    # IMPORTANTE: En cPanel, el nombre del usuario MySQL puede tener un prefijo automático
    # Verificar el nombre real del usuario creado
    sleep 2  # Esperar un momento para que cPanel/MySQL procese
    local actual_db_user

    if [ "$cpanel_user_exists" -eq 1 ]; then
      # Si el usuario cPanel existe, usar cPanel API
      if [ "$HAS_JQ" = true ]; then
        actual_db_user=$(uapi --user="$cpanel_user" Mysql list_users --output=json 2>/dev/null | \
          jq -r ".data[]?.user // empty" 2>/dev/null | \
          grep -E "^${cpanel_user}_${db_user}$|^${db_user}$" | head -1)
      else
        actual_db_user=$(uapi --user="$cpanel_user" Mysql list_users 2>/dev/null | \
          grep -oE "\"user\": *\"[^\"]+\"" | \
          grep -E "${cpanel_user}_${db_user}|${db_user}" | \
          cut -d'"' -f4 | head -1)
      fi
    fi

    # Si no se encontró desde cPanel API, buscar directamente en MySQL
    if [ -z "$actual_db_user" ]; then
      actual_db_user=$(get_mysql_user_name_directly "$cpanel_user" "$db_user")
    fi

    # Si encontramos un nombre diferente, usar ese
    if [ -n "$actual_db_user" ] && [ "$actual_db_user" != "$db_user" ]; then
      echo "⚠️  Usuario MySQL creado con nombre diferente: '$actual_db_user' (esperado: '$db_user')" >&2
      echo "   Usando el nombre real: '$actual_db_user'" >&2
      db_user="$actual_db_user"
    elif [ -z "$actual_db_user" ]; then
      # Si no encontramos el usuario, puede que use el nombre exacto que pasamos
      # O puede que necesite el prefijo completo
      local prefixed_user="${cpanel_user}_${db_user}"
      actual_db_user=$(get_mysql_user_name_directly "$cpanel_user" "$prefixed_user")

      if [ -n "$actual_db_user" ]; then
        echo "⚠️  Usuario encontrado con prefijo completo: '$actual_db_user'" >&2
        db_user="$actual_db_user"
      else
        echo "⚠️  No se pudo determinar el nombre real del usuario MySQL" >&2
        echo "   Usando el nombre proporcionado: '$db_user'" >&2
        echo "   Si hay problemas de conexión, verifica el nombre del usuario" >&2
      fi
    fi
  fi

  # Asignar privilegios con mejor manejo de errores
  if [ "$cpanel_user_exists" -eq 1 ]; then
    # Usar cPanel API si el usuario existe
    local priv_result
    priv_result=$(uapi --user="$cpanel_user" Mysql set_privileges_on_database user="$db_user" database="$db_name" privileges=ALL 2>&1)
    if [ $? -ne 0 ]; then
      echo "⚠️  Advertencia: No se pudieron asignar privilegios (puede que ya estén asignados)" >&2
      echo "   Detalles: $priv_result" >&2
      # No retornar error aquí, ya que los privilegios pueden estar asignados previamente
    else
      echo "✅ Privilegios asignados correctamente" >&2
    fi
  else
    # Si el usuario cPanel no existe, asignar privilegios directamente desde MySQL
    if command -v mysql >/dev/null 2>&1; then
      mysql -e "GRANT ALL PRIVILEGES ON \`${db_name}\`.* TO '${db_user}'@'localhost';" 2>&1
      if [ $? -eq 0 ]; then
        mysql -e "FLUSH PRIVILEGES;" 2>/dev/null
        echo "✅ Privilegios asignados correctamente desde MySQL" >&2
      else
        echo "⚠️  Advertencia: No se pudieron asignar privilegios (puede que ya estén asignados)" >&2
      fi
    else
      echo "⚠️  No se pueden asignar privilegios: mysql client no disponible" >&2
    fi
  fi

  # Esperar un momento para que MySQL procese los cambios
  echo "⏳ Esperando que MySQL procese los cambios del usuario..." >&2
  sleep 3

  # Verificar que el usuario puede conectarse (solo si mysql client está disponible)
  # Probar con el nombre proporcionado y con prefijo del cPanel user
  if command -v mysql >/dev/null 2>&1; then
    local test_connection
    local test_user="$db_user"

    # Probar primero con el nombre proporcionado
    test_connection=$(mysql -u"$test_user" -p"$db_pass" -h localhost "$db_name" -e "SELECT 1" 2>&1)
    if [ $? -ne 0 ]; then
      # Si falla, probar con prefijo del cPanel user
      test_user="${cpanel_user}_${db_user}"
      test_connection=$(mysql -u"$test_user" -p"$db_pass" -h localhost "$db_name" -e "SELECT 1" 2>&1)
      if [ $? -eq 0 ]; then
        echo "✅ Verificación: Usuario MySQL puede conectarse con nombre '$test_user'" >&2
        db_user="$test_user"  # Actualizar el nombre del usuario para usar en .env
      fi
    else
      echo "✅ Verificación: Usuario MySQL puede conectarse correctamente" >&2
    fi

    if [ $? -ne 0 ]; then
      echo "⚠️  Advertencia: No se pudo verificar la conexión del usuario MySQL inmediatamente" >&2
      echo "   Probado: '$db_user' y '${cpanel_user}_${db_user}'" >&2
      echo "   Esto puede ser normal si MySQL aún está procesando los cambios" >&2
      echo "   El script continuará de todas formas" >&2
    fi
  fi

  echo "✅ Base de datos y usuario configurados:" >&2
  echo "   Base: $db_name" >&2
  echo "   Usuario: $db_user" >&2
  echo "   Contraseña: $db_pass" >&2

  # Guardar credenciales (solo si no estaban guardadas previamente)
  # Verificar si ya existen en el archivo de credenciales
  if ! grep -q "Cuenta cPanel: $cpanel_user" "$CRED_FILE" 2>/dev/null || \
     ! grep -A 3 "Cuenta cPanel: $cpanel_user" "$CRED_FILE" | grep -q "Usuario DB: $db_user"; then
    {
      echo "Cuenta cPanel: $cpanel_user"
      echo "Base de datos: $db_name"
      echo "Usuario DB: $db_user"
      echo "Contraseña DB: $db_pass"
    } >> "$CRED_FILE"
  fi

  # Retornar valores para uso posterior (solo stdout, sin mensajes)
  echo "$db_name|$db_user|$db_pass"
}

create_account() {
  local domain="$1"
  local user="$2"
  local pass="$3"
  local plan="$4"
  local email="$5"
  local quota="$6"
  local json_file="$7"

  echo "🧩 Creando cuenta: $domain ($user)"
  if user_exists "$user"; then
    echo "⚠️ Usuario $user ya existe."

    # Si hay JSON, verificar y crear base de datos MySQL si es necesario
    if [ -n "$json_file" ] && [ -f "$json_file" ]; then
      local db_create=$(read_json_value ".project.database.create" "$json_file")

      # Crear base de datos MySQL si está configurado para crearse
      if [ "$db_create" = "true" ]; then
        echo "🔍 Verificando base de datos MySQL para usuario existente..."
        local db_creds=$(create_mysql_for_new_cpanel_user "$user" "$json_file")

        if [ $? -eq 0 ] && [ -n "$db_creds" ]; then
          echo "✅ Base de datos MySQL configurada correctamente"
        else
          echo "⚠️  Hubo problemas al configurar la base de datos MySQL"
        fi
      fi

      # Continuar con repositorio si está configurado
      local repo_url=$(read_json_value ".project.repository_url" "$json_file")
      local branch_name=$(read_json_value ".project.branch" "$json_file")
      branch_name=${branch_name:-"cd-system"}

      if [ -n "$repo_url" ] && [ "$repo_url" != "null" ]; then
        local home_dir="/home/$user"
        local public_html="$home_dir/public_html"
        local repo_name=$(basename "$repo_url" .git)
        local repo_path="$public_html/$repo_name"

        # Verificar si el repo ya está clonado
        if [ ! -d "$repo_path/.git" ]; then
          echo "📂 Repositorio no encontrado. Continuando con clonado..."
          setup_ssh_keys "$user"
          # Pasar credenciales de BD si se crearon
          clone_repo_in_public_html "$user" "$repo_url" "$branch_name" "$json_file" "$db_creds" "$domain"
        else
          echo "✅ Repositorio ya existe en $repo_path"
          echo "💡 Si necesitas reconfigurar, elimina el directorio y vuelve a ejecutar"

          # Si el repositorio ya existe pero necesitamos configurar .env con las credenciales de BD
          if [ -n "$db_creds" ] && [ -d "$repo_path" ]; then
            echo "🔧 Actualizando configuración del proyecto con credenciales de BD..."
            local db_name=$(echo "$db_creds" | cut -d'|' -f1)
            local db_user=$(echo "$db_creds" | cut -d'|' -f2)
            local db_pass=$(echo "$db_creds" | cut -d'|' -f3)
            local site_url=$(read_json_value ".identity.site_url" "$json_file")
            local site_name=$(read_json_value ".identity.site_name" "$json_file")

            if [ -z "$site_url" ] || [ "$site_url" = "null" ]; then
              site_url="https://${user}.bewpro.com"
            fi
            if [ -z "$site_name" ] || [ "$site_name" = "null" ]; then
              site_name="$user"
            fi

            local php_cli=$(find_php_cli "$user")
            generate_env_file "$user" "$repo_path" "$db_name" "$db_user" "$db_pass" "$site_url" "$site_name" "$php_cli"
          fi
        fi
      fi
    fi

    return
  fi

  if (( DRY_RUN )); then
    echo "[DRY-RUN] whmapi1 createacct domain=$domain username=$user password=$pass plan=$plan"
    setup_ssh_keys "$user"
    return
  fi

  # Crear cuenta con mejor manejo de errores
  local create_result
  if (( VERBOSE )); then
    create_result=$(whmapi1 createacct domain="$domain" username="$user" password="$pass" plan="$plan" contactemail="$email" quota="$quota" 2>&1)
    echo "$create_result"
  else
    create_result=$(whmapi1 createacct domain="$domain" username="$user" password="$pass" plan="$plan" contactemail="$email" quota="$quota" 2>&1)
  fi

  # Verificar si hubo errores en la creación
  if echo "$create_result" | grep -qi "error\|failed\|denied"; then
    echo "❌ Error al crear la cuenta cPanel:" >&2
    echo "$create_result" | grep -i "error\|message\|reason" | head -5 >&2
    return 1
  fi

  # Esperar un momento para que cPanel procese la creación
  sleep 2

  if user_exists "$user"; then
    echo "✅ Cuenta creada con éxito: $domain ($user)"
    echo "$domain,$user,$pass,$plan,$email,$quota" >> "$CREATED"

    # Guardar credenciales cPanel
    {
      echo "Cuenta cPanel: $user"
      echo "Contraseña: $pass"
    } >> "$CRED_FILE"

    setup_ssh_keys "$user"

    # Crear BD si está en JSON o preguntar
    local create_db="n"
    if [ -n "$json_file" ] && [ -f "$json_file" ]; then
      local db_create=$(read_json_value ".project.database.create" "$json_file")
      if [ "$db_create" = "true" ]; then
        create_db="s"
      fi
    else
      read -rp "🧩 ¿Querés crear la base de datos MySQL para $user? (s/n): " create_db
    fi

    # Capturar credenciales de BD si se crea
    local db_creds=""
    if [[ "$create_db" =~ ^[sS]$ ]]; then
      db_creds=$(create_mysql_for_new_cpanel_user "$user" "$json_file")
    fi

    # Clonar repo si está en JSON o preguntar
    local clone_choice="n"
    local repo_url=""
    local branch_name="cd-system"

    if [ -n "$json_file" ] && [ -f "$json_file" ]; then
      repo_url=$(read_json_value ".project.repository_url" "$json_file")
      branch_name=$(read_json_value ".project.branch" "$json_file")
      branch_name=${branch_name:-"cd-system"}

      if [ -n "$repo_url" ] && [ "$repo_url" != "null" ]; then
        clone_choice="s"
      fi
    else
      read -rp "🔗 ¿Querés clonar un repositorio en public_html? (s/n): " clone_choice
      if [[ "$clone_choice" =~ ^[sS]$ ]]; then
        read -rp "🔗 Ingresá el link del repositorio de GitHub: " repo_url
        read -rp "🔍 Ingresá el nombre de la rama que querés usar: " branch_name
        branch_name=${branch_name:-"cd-system"}
      fi
    fi

    if [[ "$clone_choice" =~ ^[sS]$ ]] && [ -n "$repo_url" ]; then
      clone_repo_in_public_html "$user" "$repo_url" "$branch_name" "$json_file" "$db_creds" "$domain"
    fi
  else
    echo "❌ Error al crear la cuenta $user"
  fi
}

# --- Procesamiento de argumentos ---
while [[ $# -gt 0 ]]; do
  case "$1" in
    --json) JSON_FILE="$2"; shift 2 ;;
    --json-url) JSON_URL="$2"; shift 2 ;;
    --csv) CSV_FILE="$2"; shift 2 ;;
    --interactive) INTERACTIVE=1; shift ;;
    --dry-run) DRY_RUN=1; shift ;;
    --verbose) VERBOSE=1; shift ;;
    --help) print_help; exit 0 ;;
    *) echo "Opción desconocida: $1"; print_help; exit 1 ;;
  esac
done

require_root
touch "$LOGFILE" "$CRED_FILE"
log "Iniciando creación (DRY_RUN=$DRY_RUN, VERBOSE=$VERBOSE)"

# Manejar JSON
if [ -n "$JSON_URL" ]; then
  if [ "$HAS_JQ" = false ]; then
    echo "❌ jq no está instalado. Es necesario para usar JSON desde URL." >&2
    echo "Instala jq con: yum install jq o apt-get install jq" >&2
    exit 1
  fi
  JSON_FILE=$(download_json "$JSON_URL")
  if [ $? -ne 0 ]; then
    echo "❌ Error al descargar JSON desde $JSON_URL" >&2
    exit 1
  fi
  echo "✅ JSON descargado desde $JSON_URL"
fi

if [ -n "$JSON_FILE" ]; then
  if [ "$HAS_JQ" = false ]; then
    echo "❌ jq no está instalado. Es necesario para usar archivos JSON." >&2
    echo "Instala jq con: yum install jq o apt-get install jq" >&2
    exit 1
  fi

  if [ ! -f "$JSON_FILE" ]; then
    echo "❌ Archivo JSON no encontrado: $JSON_FILE" >&2
    exit 1
  fi

  if ! jq empty "$JSON_FILE" 2>/dev/null; then
    echo "❌ El archivo JSON no es válido: $JSON_FILE" >&2
    exit 1
  fi

  echo "✅ Modo JSON activado. Leyendo configuración desde: $JSON_FILE"

  # Leer valores del JSON
  DOMAIN=$(read_json_value ".project.vps.domain" "$JSON_FILE")
  CPANEL_USER=$(read_json_value ".project.vps.cpanel_username" "$JSON_FILE")
  CPANEL_PASS=$(read_json_value ".project.vps.cpanel_password" "$JSON_FILE")
  CPANEL_PLAN=$(read_json_value ".project.vps.cpanel_plan" "$JSON_FILE")
  CPANEL_EMAIL=$(read_json_value ".project.vps.cpanel_email" "$JSON_FILE")
  CPANEL_QUOTA=$(read_json_value ".project.vps.cpanel_quota" "$JSON_FILE")

  # Valores por defecto
  CPANEL_PASS=${CPANEL_PASS:-$(gen_password)}
  CPANEL_PLAN=${CPANEL_PLAN:-"default"}
  CPANEL_EMAIL=${CPANEL_EMAIL:-"admin@example.com"}
  CPANEL_QUOTA=${CPANEL_QUOTA:-0}

  # Si los valores son "null", usar defaults
  if [ "$CPANEL_PASS" = "null" ] || [ -z "$CPANEL_PASS" ]; then
    CPANEL_PASS=$(gen_password)
  fi
  if [ "$CPANEL_PLAN" = "null" ] || [ -z "$CPANEL_PLAN" ]; then
    CPANEL_PLAN="default"
  fi
  if [ "$CPANEL_EMAIL" = "null" ] || [ -z "$CPANEL_EMAIL" ]; then
    CPANEL_EMAIL="admin@example.com"
  fi
  if [ "$CPANEL_QUOTA" = "null" ] || [ -z "$CPANEL_QUOTA" ]; then
    CPANEL_QUOTA=0
  fi

  # Validar campos requeridos
  if [ -z "$DOMAIN" ] || [ "$DOMAIN" = "null" ]; then
    echo "❌ El campo 'project.vps.domain' es requerido en el JSON" >&2
    exit 1
  fi

  if [ -z "$CPANEL_USER" ] || [ "$CPANEL_USER" = "null" ]; then
    echo "❌ El campo 'project.vps.cpanel_username' es requerido en el JSON" >&2
    exit 1
  fi

  # Truncar usuario si es necesario
  MAX_LEN=$(get_max_username_length)
  CPANEL_USER="${CPANEL_USER:0:$MAX_LEN}"

  echo "📋 Configuración desde JSON:"
  echo "   Dominio: $DOMAIN"
  echo "   Usuario: $CPANEL_USER"
  echo "   Plan: $CPANEL_PLAN"
  echo ""

  create_account "$DOMAIN" "$CPANEL_USER" "$CPANEL_PASS" "$CPANEL_PLAN" "$CPANEL_EMAIL" "$CPANEL_QUOTA" "$JSON_FILE"

  # Limpiar archivo temporal si se descargó
  if [ -n "$JSON_URL" ] && [ -f "$JSON_FILE" ]; then
    rm -f "$JSON_FILE"
  fi

  log "✅ Proceso JSON finalizado. Revisá $CREATED y $LOGFILE"
  exit 0
fi

echo "domain,username,password,plan,email,quota" > "$CREATED"

MAX_LEN=$(get_max_username_length)
log "Límite máximo de caracteres de usuario: $MAX_LEN"

### --- MODO CSV ---
if [[ -n "$CSV_FILE" ]]; then
  if [[ ! -f "$CSV_FILE" ]]; then
    echo "❌ CSV no encontrado: $CSV_FILE" >&2
    exit 1
  fi
  tail -n +1 "$CSV_FILE" | while IFS=',' read -r domain user pass plan email quota; do
    [[ -z "$domain" ]] && continue
    pass=${pass:-$(gen_password)}
    plan=${plan:-default}
    email=${email:-"admin@example.com"}
    quota=${quota:-0}
    user="${user:0:$MAX_LEN}"
    create_account "$domain" "$user" "$pass" "$plan" "$email" "$quota" ""
    sleep 1
  done
  log "✅ Proceso CSV finalizado. Revisá $CREATED y $LOGFILE"
  exit 0
fi

### --- MODO INTERACTIVO ---
if (( INTERACTIVE )); then
  log "Modo interactivo habilitado."
  while true; do
    echo "---------------------------------------------"
    read -rp "Dominio: " domain
    read -rp "Usuario (máx $MAX_LEN caracteres): " user
    read -rsp "Contraseña (dejar vacío para generar): " pass; echo
    read -rp "Plan (default): " plan
    read -rp "Email contacto (admin@example.com): " email
    read -rp "Cuota (MB, 0=ilimitado): " quota

    pass=${pass:-$(gen_password)}
    plan=${plan:-default}
    email=${email:-"admin@example.com"}
    quota=${quota:-0}
    user="${user:0:$MAX_LEN}"

    create_account "$domain" "$user" "$pass" "$plan" "$email" "$quota" ""

    read -rp "¿Deseás crear otra cuenta? (s/n): " again
    [[ "$again" =~ ^[sS]$ ]] || break
  done
  log "✅ Proceso interactivo finalizado. Revisá $CREATED y $LOGFILE"
  exit 0
fi

print_help
exit 0