# Verificar la versión de Python
python3 --version

# Instalar pip si no está disponible
sudo apt-get install -y python3-pip python3-venv

# En CentOS/Rocky
sudo dnf install -y python3-pip

# Crear el directorio de trabajo para Jupyter
mkdir -p ~/jupyter-server
cd ~/jupyter-server

# Crear un entorno virtual dedicado
python3 -m venv venv

# Activar el entorno virtual
source venv/bin/activate

# Instalar JupyterLab (incluye Jupyter Notebook clásico)
pip install jupyterlab notebook

# Verificar la instalación
jupyter --version
jupyter lab --version

# Instalar como root para disponibilidad global
sudo pip3 install jupyterlab notebook

# O usando el gestor de paquetes del sistema (Ubuntu)
sudo apt-get install -y jupyter-notebook

# Instalar Miniconda si no está disponible
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh -b -p ~/miniconda3
~/miniconda3/bin/conda init bash
source ~/.bashrc

# Instalar JupyterLab en el entorno base
conda install -y jupyterlab notebook

# Generar la configuración por defecto de Jupyter
jupyter lab --generate-config

# El archivo se crea en:
# ~/.jupyter/jupyter_lab_config.py

# Generar y guardar la contraseña cifrada
jupyter lab password
# Introduce la contraseña dos veces
# Se guarda automáticamente en ~/.jupyter/jupyter_server_config.json

# Editar el archivo de configuración
cat >> ~/.jupyter/jupyter_lab_config.py << 'EOF'

# Escuchar en todas las interfaces (para acceso remoto)
c.ServerApp.ip = '0.0.0.0'

# Puerto de escucha
c.ServerApp.port = 8888

# No abrir el navegador automáticamente (es un servidor remoto)
c.ServerApp.open_browser = False

# Directorio base para los notebooks
c.ServerApp.notebook_dir = '/home/usuario/notebooks'

# Permitir acceso desde origen cruzado (si usas proxy Nginx)
c.ServerApp.allow_origin = '*'

# Deshabilitar el token si usas contraseña
# c.ServerApp.token = ''  # Dejar vacío para usar contraseña en su lugar
EOF

# Crear el directorio de notebooks
mkdir -p ~/notebooks

# Crear el archivo de servicio (ajusta el usuario y las rutas)
sudo cat > /etc/systemd/system/jupyter.service << 'EOF'
[Unit]
Description=Servidor JupyterLab
After=network.target

[Service]
Type=simple
User=usuario
WorkingDirectory=/home/usuario/notebooks
# Activar el entorno virtual antes de iniciar
ExecStart=/home/usuario/jupyter-server/venv/bin/jupyter lab \
    --config=/home/usuario/.jupyter/jupyter_lab_config.py
Restart=on-failure
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF

# Recargar systemd y habilitar el servicio
sudo systemctl daemon-reload
sudo systemctl enable jupyter
sudo systemctl start jupyter

# Verificar el estado
sudo systemctl status jupyter

# Ver los logs
sudo journalctl -u jupyter -f

sudo apt-get install -y certbot python3-certbot-nginx
sudo certbot --nginx -d jupyter.tudominio.com

# /etc/nginx/sites-available/jupyter
server {
    listen 80;
    server_name jupyter.tudominio.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    server_name jupyter.tudominio.com;

    ssl_certificate /etc/letsencrypt/live/jupyter.tudominio.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/jupyter.tudominio.com/privkey.pem;

    # Seguridad SSL estricta
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;

    # Tamaño máximo de subida (para notebooks grandes)
    client_max_body_size 100M;

    location / {
        proxy_pass http://127.0.0.1:8888;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # Soporte para WebSockets (necesario para Jupyter)
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";

        # Timeouts para operaciones largas
        proxy_read_timeout 86400;
        proxy_connect_timeout 86400;
        proxy_send_timeout 86400;
    }
}

# Activar la configuración
sudo ln -s /etc/nginx/sites-available/jupyter /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

# Crear un entorno virtual para un proyecto específico
python3 -m venv ~/proyectos/mi-proyecto/venv
source ~/proyectos/mi-proyecto/venv/bin/activate

# Instalar ipykernel en el entorno
pip install ipykernel

# Registrar el entorno como kernel de Jupyter
python -m ipykernel install \
  --user \
  --name "mi-proyecto" \
  --display-name "Python (mi-proyecto)"

# Volver al entorno base
deactivate

# Listar los kernels disponibles
jupyter kernelspec list

# Salida esperada:
# Available kernels:
#   python3       /usr/share/jupyter/kernels/python3
#   mi-proyecto   /home/usuario/.local/share/jupyter/kernels/mi-proyecto

# Eliminar un kernel que ya no se necesita
jupyter kernelspec remove mi-proyecto

# Instalar el kernel de R (si R está instalado)
sudo apt-get install -y r-base
R -e "install.packages('IRkernel'); IRkernel::installspec(user=FALSE)"

# Crear entorno con TensorFlow y GPU
python3 -m venv ~/venvs/tensorflow-gpu
source ~/venvs/tensorflow-gpu/bin/activate

pip install tensorflow[and-cuda] ipykernel

python -m ipykernel install \
  --user \
  --name "tensorflow-gpu" \
  --display-name "TensorFlow GPU"

# Verificar que la GPU es accesible desde el kernel
python3 -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"

# Iniciar JupyterLab (interfaz moderna con panel lateral y múltiples vistas)
jupyter lab

# Iniciar el Notebook clásico (interfaz simple, mayor compatibilidad)
jupyter notebook

# Instalar extensiones en JupyterLab
pip install jupyterlab-git              # Integración con Git
pip install jupyterlab-code-formatter   # Formateo de código
pip install jupyterlab-lsp              # Autocompletado LSP

# Instalar extensiones útiles para data science
pip install ipywidgets                  # Widgets interactivos
pip install matplotlib                  # Gráficos inline
pip install pandas numpy scikit-learn   # Librerías esenciales

# Desde tu máquina local, crear un tunnel SSH
# Reemplaza PUERTO_LOCAL, USUARIO y IP_SERVIDOR
ssh -L 8888:localhost:8888 usuario@IP_SERVIDOR -N

# Con una clave específica
ssh -i ~/.ssh/mi-clave -L 8888:localhost:8888 usuario@IP_SERVIDOR -N

# Ejecutar en segundo plano
ssh -i ~/.ssh/mi-clave -L 8888:localhost:8888 usuario@IP_SERVIDOR -fN

# Ahora accede a Jupyter desde tu navegador local:
# http://localhost:8888

# Verificar el usuario del servicio systemd
sudo journalctl -u jupyter -n 20

# Verificar permisos del directorio de notebooks
ls -la ~/notebooks/
chown -R usuario:usuario ~/notebooks/

# Verificar que el WebSocket funciona correctamente
# Comprobar los logs de Nginx
sudo tail -f /var/log/nginx/error.log

# Asegurarse de que la directiva 'upgrade' está en la configuración
grep -A5 "proxy_http_version" /etc/nginx/sites-available/jupyter

# Aumentar los timeouts en la configuración de Jupyter
cat >> ~/.jupyter/jupyter_lab_config.py << 'EOF'
# Tiempo máximo de espera para el kernel (segundos)
c.MappingKernelManager.cull_idle_timeout = 0
c.MappingKernelManager.cull_interval = 0
EOF

sudo systemctl restart jupyter

# Instalar paquetes desde una celda del notebook
# Usar el ejecutable de pip del kernel activo
import sys
!{sys.executable} -m pip install pandas

# O directamente
%pip install pandas