#!/usr/bin/env bash
# bulk_create_cpanel4.sh - Versión mejorada con soporte JSON
# Crear cuentas cPanel en masa o de forma interactiva con DB y setup
# Compatible con WHM API 1 (createacct)
# Uso: sudo ./bulk_create_cpanel4.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_cpanel4.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_cpanel4.sh --json /path/to/mi-proyecto.json
  ./bulk_create_cpanel4.sh --json-url https://raw.githubusercontent.com/user/repo/branch/mi-proyecto.json
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."
  echo "    En cPanel sería: Select PHP Version -> Extensions -> habilitar fileinfo, etc."
}

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"

  sudo -u "$username" bash -c "
    cd \"$project_path\" || exit 1
    if [ ! -f .env ]; then
      cp .env.example .env
    fi

    # Escapar caracteres especiales para sed (método más robusto)
    # Usar perl o awk sería mejor, pero sed es más común
    db_name_escaped=\$(printf '%s\n' \"$db_name\" | sed 's/[[\.*^$()+?{|]/\\\\&/g')
    db_user_escaped=\$(printf '%s\n' \"$db_user\" | sed 's/[[\.*^$()+?{|]/\\\\&/g')
    db_pass_escaped=\$(printf '%s\n' \"$db_pass\" | sed 's/[[\.*^$()+?{|]/\\\\&/g')
    site_name_escaped=\$(printf '%s\n' \"$site_name\" | sed 's/[[\.*^$()+?{|]/\\\\&/g')
    site_url_escaped=\$(printf '%s\n' \"$site_url\" | sed 's/[[\.*^$()+?{|]/\\\\&/g')

    # Actualizar valores usando delimitador | y patrones más flexibles
    # Permitir espacios opcionales alrededor del =
    sed -i \"s|^APP_NAME=.*|APP_NAME=\\\"\$site_name_escaped\\\"|\" .env
    sed -i \"s|^APP_URL=.*|APP_URL=\$site_url_escaped|\" .env
    sed -i \"s|^DB_DATABASE=.*|DB_DATABASE=\$db_name_escaped|\" .env
    sed -i \"s|^DB_USERNAME=.*|DB_USERNAME=\$db_user_escaped|\" .env
    sed -i \"s|^DB_PASSWORD=.*|DB_PASSWORD=\$db_pass_escaped|\" .env

    # Generar APP_KEY si no existe
    if ! grep -q 'APP_KEY=' .env || grep -q 'APP_KEY=\$' .env; then
      $php_cli artisan key:generate --force 2>/dev/null || true
    fi
  "

  echo "✅ Archivo .env generado y configurado"
}

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"

    # 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

      # 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

      # Ejecutar comandos artisan
      bash -c \"$php_cli artisan migrate:fresh --seed --force\" || true
      bash -c \"$php_cli artisan storage:link\" || true
    "
    echo "✅ Setup ejecutado correctamente."
  else
    echo "❌ No se encontró el script en $setup_script"
  fi
}

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 que el usuario cPanel existe
  if ! user_exists "$cpanel_user"; then
    echo "❌ El usuario cPanel $cpanel_user no existe" >&2
    return 1
  fi

  # Crear base de datos con mejor manejo de errores
  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

  # Crear usuario con mejor manejo de errores
  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 usuario ya existe
    if echo "$user_result" | grep -qi "already exists\|duplicate"; then
      echo "⚠️  El usuario $db_user ya existe, continuando..." >&2
    else
      return 1
    fi
  fi

  # Asignar privilegios con mejor manejo de errores
  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 "❌ Error al asignar privilegios" >&2
    echo "   Detalles: $priv_result" >&2
    return 1
  fi

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

  # Guardar credenciales
  {
    echo "Cuenta cPanel: $cpanel_user"
    echo "Base de datos: $db_name"
    echo "Usuario DB: $db_user"
    echo "Contraseña DB: $db_pass"
  } >> "$CRED_FILE"

  # 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 y el repo no está clonado, continuar con clonado y setup
    if [ -n "$json_file" ] && [ -f "$json_file" ]; then
      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"
          clone_repo_in_public_html "$user" "$repo_url" "$branch_name" "$json_file" "" "$domain"
        else
          echo "✅ Repositorio ya existe en $repo_path"
          echo "💡 Si necesitas reconfigurar, elimina el directorio y vuelve a ejecutar"
        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