#!/bin/bash

# Script para generar nueva clave SSH para el sistema NAT industrial
# Ejecutar desde PC1 (WSL2)

set -e

echo "🔐 Generación de Clave SSH para Sistema NAT Industrial"
echo "===================================================="

# Configuración
SSH_KEY_NAME="industrial_nat_key"
SSH_KEY_PATH="/home/miguefin/proxytcp/certs/ssh_private_key"
SSH_PUB_PATH="/home/miguefin/proxytcp/certs/ssh_private_key.pub"
PC3_HOST="91.99.210.72"

echo ""
echo "📍 Información:"
echo "   Clave privada: $SSH_KEY_PATH"
echo "   Clave pública: $SSH_PUB_PATH"
echo "   Servidor destino: $PC3_HOST"
echo ""

# Función para generar clave SSH
generate_ssh_key() {
    echo "🔑 Generando nueva clave SSH..."
    
    # Crear directorio si no existe
    mkdir -p "$(dirname "$SSH_KEY_PATH")"
    
    # Generar clave SSH
    ssh-keygen -t rsa -b 4096 -f "$SSH_KEY_PATH" -N "" -C "industrial-nat-$(whoami)@$(hostname)-$(date +%Y%m%d)"
    
    # Establecer permisos correctos
    chmod 600 "$SSH_KEY_PATH"
    chmod 644 "$SSH_PUB_PATH"
    
    echo "✅ Clave SSH generada exitosamente"
    echo "   Privada: $SSH_KEY_PATH"
    echo "   Pública: $SSH_PUB_PATH"
}

# Función para mostrar clave pública
show_public_key() {
    echo ""
    echo "📋 CLAVE PÚBLICA (copiar esta en PC3):"
    echo "======================================"
    cat "$SSH_PUB_PATH"
    echo "======================================"
}

# Función para crear script de instalación en PC3
create_pc3_setup_script() {
    local setup_script="/tmp/setup_pc3_nat.sh"
    
    cat > "$setup_script" << 'EOF'
#!/bin/bash

# Script para configurar PC3 como intermediario SSH NAT
# Ejecutar en PC3 (91.99.210.72)

set -e

echo "🖥️ Configurando PC3 como Intermediario SSH NAT"
echo "=============================================="

# Verificar si somos root o tenemos sudo
if [[ $EUID -eq 0 ]]; then
    SUDO=""
else
    SUDO="sudo"
fi

# Función para instalar SSH server si no está
install_ssh_server() {
    echo "📦 Verificando SSH Server..."
    
    if ! systemctl is-active --quiet ssh && ! systemctl is-active --quiet sshd; then
        echo "   Instalando OpenSSH Server..."
        $SUDO apt update
        $SUDO apt install -y openssh-server
        echo "✅ SSH Server instalado"
    else
        echo "✅ SSH Server ya está instalado"
    fi
}

# Función para configurar SSH para túneles reversos
configure_ssh() {
    echo "⚙️ Configurando SSH para túneles reversos..."
    
    local ssh_config="/etc/ssh/sshd_config"
    local backup_config="/etc/ssh/sshd_config.backup.$(date +%Y%m%d_%H%M%S)"
    
    # Hacer backup de configuración
    $SUDO cp "$ssh_config" "$backup_config"
    echo "   Backup creado: $backup_config"
    
    # Configurar GatewayPorts si no está
    if ! grep -q "^GatewayPorts yes" "$ssh_config"; then
        echo "GatewayPorts yes" | $SUDO tee -a "$ssh_config" > /dev/null
        echo "   ✅ GatewayPorts habilitado"
    else
        echo "   ✅ GatewayPorts ya estaba habilitado"
    fi
    
    # Configurar AllowTcpForwarding si no está
    if ! grep -q "^AllowTcpForwarding yes" "$ssh_config"; then
        echo "AllowTcpForwarding yes" | $SUDO tee -a "$ssh_config" > /dev/null
        echo "   ✅ AllowTcpForwarding habilitado"
    else
        echo "   ✅ AllowTcpForwarding ya estaba habilitado"
    fi
    
    # Reiniciar SSH
    echo "   Reiniciando SSH Server..."
    $SUDO systemctl restart ssh 2>/dev/null || $SUDO systemctl restart sshd
    echo "✅ SSH Server reiniciado"
}

# Función para configurar firewall
configure_firewall() {
    echo "🔥 Configurando Firewall..."
    
    # Verificar si ufw está instalado y activo
    if command -v ufw >/dev/null 2>&1; then
        if $SUDO ufw status | grep -q "Status: active"; then
            echo "   UFW está activo, configurando reglas..."
            $SUDO ufw allow 22/tcp comment "SSH"
            $SUDO ufw allow 9000:9999/tcp comment "NAT Tunnels"
            echo "✅ Reglas UFW configuradas"
        else
            echo "   UFW está instalado pero inactivo"
        fi
    else
        echo "   UFW no está instalado"
    fi
    
    # Verificar iptables básico
    if command -v iptables >/dev/null 2>&1; then
        echo "   Verificando reglas iptables básicas..."
        # Solo mostrar info, no modificar iptables automáticamente
        echo "   ℹ️ Si usas iptables, asegúrate de permitir puertos 22 y 9000-9999"
    fi
}

# Función para configurar clave SSH
setup_ssh_key() {
    echo "🔑 Configurando autenticación por clave SSH..."
    
    read -p "👤 ¿Cuál es tu usuario SSH en este servidor? (default: $USER): " ssh_user
    ssh_user=${ssh_user:-$USER}
    
    local home_dir
    if [[ "$ssh_user" == "root" ]]; then
        home_dir="/root"
    else
        home_dir="/home/$ssh_user"
    fi
    
    local ssh_dir="$home_dir/.ssh"
    local auth_keys="$ssh_dir/authorized_keys"
    
    echo "   Configurando para usuario: $ssh_user"
    echo "   Directorio SSH: $ssh_dir"
    
    # Crear directorio .ssh si no existe
    if [[ "$ssh_user" == "$USER" ]]; then
        mkdir -p "$ssh_dir"
        chmod 700 "$ssh_dir"
    else
        $SUDO mkdir -p "$ssh_dir"
        $SUDO chmod 700 "$ssh_dir"
        $SUDO chown "$ssh_user:$ssh_user" "$ssh_dir"
    fi
    
    echo ""
    echo "📋 AHORA NECESITAS AGREGAR TU CLAVE PÚBLICA"
    echo "==========================================="
    echo "1. Copia la clave pública que se mostró en PC1"
    echo "2. Pégala cuando se solicite"
    echo ""
    echo "Formato esperado: ssh-rsa AAAAB3NzaC1yc2EAAA... comentario"
    echo ""
    
    read -p "📝 Pega tu clave pública SSH aquí: " public_key
    
    if [[ -z "$public_key" ]]; then
        echo "❌ No se proporcionó clave pública"
        return 1
    fi
    
    # Validar formato básico de clave SSH
    if [[ "$public_key" =~ ^(ssh-rsa|ssh-ed25519|ecdsa-sha2-) ]]; then
        # Agregar clave a authorized_keys
        if [[ "$ssh_user" == "$USER" ]]; then
            echo "$public_key" >> "$auth_keys"
            chmod 600 "$auth_keys"
        else
            echo "$public_key" | $SUDO tee -a "$auth_keys" > /dev/null
            $SUDO chmod 600 "$auth_keys"
            $SUDO chown "$ssh_user:$ssh_user" "$auth_keys"
        fi
        
        echo "✅ Clave SSH agregada para usuario $ssh_user"
    else
        echo "❌ Formato de clave SSH inválido"
        return 1
    fi
}

# Función para verificar configuración
verify_setup() {
    echo "🧪 Verificando configuración..."
    
    # Verificar SSH está ejecutándose
    if systemctl is-active --quiet ssh || systemctl is-active --quiet sshd; then
        echo "✅ SSH Server está ejecutándose"
    else
        echo "❌ SSH Server no está ejecutándose"
        return 1
    fi
    
    # Verificar puerto 22
    if netstat -tlnp 2>/dev/null | grep -q ":22 " || ss -tlnp 2>/dev/null | grep -q ":22 "; then
        echo "✅ Puerto 22 está abierto"
    else
        echo "❌ Puerto 22 no está escuchando"
        return 1
    fi
    
    # Mostrar información de conexión
    local external_ip
    external_ip=$(curl -s ifconfig.me 2>/dev/null || curl -s ipinfo.io/ip 2>/dev/null || echo "IP_NO_DETECTADA")
    
    echo ""
    echo "📊 INFORMACIÓN DE CONEXIÓN:"
    echo "=========================="
    echo "   IP Externa: $external_ip"
    echo "   Puerto SSH: 22"
    echo "   Rango puertos NAT: 9000-9999"
    echo ""
}

# Función principal
main() {
    echo "Iniciando configuración de PC3..."
    echo ""
    
    install_ssh_server
    configure_ssh
    configure_firewall
    setup_ssh_key
    verify_setup
    
    echo ""
    echo "🎉 ¡Configuración de PC3 completada!"
    echo ""
    echo "📋 PRÓXIMOS PASOS:"
    echo "1. Probar conexión SSH desde PC1:"
    echo "   ssh -i certs/ssh_private_key usuario@$(hostname -I | awk '{print $1}')"
    echo ""
    echo "2. Si la conexión SSH funciona, ejecutar en PC1:"
    echo "   ./setup.sh"
    echo ""
    echo "3. Usar el sistema NAT desde PC2:"
    echo "   python nat_client.py plc 10.1.33.11 vnc"
    echo ""
}

# Ejecutar función principal
main "$@"
EOF

    chmod +x "$setup_script"
    echo ""
    echo "📄 Script de configuración de PC3 creado: $setup_script"
}

# Función principal
main() {
    echo "Generando nueva clave SSH para el sistema NAT industrial..."
    echo ""
    
    # Verificar si ya existe una clave
    if [[ -f "$SSH_KEY_PATH" ]]; then
        echo "⚠️ Ya existe una clave SSH en: $SSH_KEY_PATH"
        echo ""
        read -p "¿Quieres sobrescribirla? (y/N): " -n 1 -r
        echo
        if [[ ! $REPLY =~ ^[Yy]$ ]]; then
            echo "❌ Operación cancelada"
            exit 1
        fi
        echo ""
    fi
    
    # Generar nueva clave SSH
    generate_ssh_key
    
    # Mostrar clave pública
    show_public_key
    
    # Crear script para PC3
    create_pc3_setup_script
    
    echo ""
    echo "🎯 PRÓXIMOS PASOS:"
    echo "================="
    echo ""
    echo "1. 📋 COPIAR la clave pública mostrada arriba"
    echo ""
    echo "2. 🖥️ En PC3 (91.99.210.72), ejecutar:"
    echo "   wget -O- https://pastebin.com/raw/XXXXXXXX | bash"
    echo "   (o copiar manualmente el script /tmp/setup_pc3_nat.sh)"
    echo ""
    echo "3. 🧪 PROBAR conexión SSH desde aquí:"
    echo "   ssh -i $SSH_KEY_PATH usuario@$PC3_HOST"
    echo ""
    echo "4. 🚀 Si funciona, ejecutar:"
    echo "   ./setup.sh"
    echo ""
    echo "5. 📱 Usar desde PC2:"
    echo "   python nat_client.py plc 10.1.33.11 vnc"
    echo ""
    
    # Mostrar información adicional
    echo "ℹ️ INFORMACIÓN DE LA CLAVE:"
    echo "   Tipo: RSA 4096 bits"
    echo "   Privada: $SSH_KEY_PATH"
    echo "   Pública: $SSH_PUB_PATH"
    echo "   Propósito: Sistema NAT Industrial"
    echo ""
    
    # Verificar si ssh-agent está disponible para cargar la clave
    if command -v ssh-agent >/dev/null 2>&1; then
        echo "💡 CONSEJO: Para cargar la clave en ssh-agent:"
        echo "   eval \$(ssh-agent -s)"
        echo "   ssh-add $SSH_KEY_PATH"
        echo ""
    fi
    
    echo "✅ ¡Nueva clave SSH generada exitosamente!"
}

# Ejecutar función principal
main "$@"