#!/bin/bash

set -e

APP_NAME="rss"
DB_NAME="rss"
DB_USER="rss"
APP_USER="x"
APP_DIR=$(pwd)
PYTHON_ENV="$APP_DIR/venv"
WSGI_APP_ENTRY="app:app"
WEB_PORT=8000

echo "🟢 Paso 0: Verificaciones y confirmación de seguridad"
if [[ $EUID -ne 0 ]]; then
   echo "❌ Este script debe ser ejecutado como root (usa sudo)."
   exit 1
fi

echo "------------------------------------------------------------------"
echo "⚠️ ADVERTENCIA: Este script realizará las siguientes acciones DESTRUCTIVAS:"
echo "   - Eliminará TODOS los servicios systemd que empiecen por '$APP_NAME'."
echo "   - Eliminará PERMANENTEMENTE la base de datos '$DB_NAME'."
echo "   - Eliminará PERMANENTEMENTE el usuario de base de datos '$DB_USER'."
echo "------------------------------------------------------------------"
read -p "Estás seguro de que quieres continuar? (escribe 'si' para confirmar): " CONFIRM
if [ "$CONFIRM" != "si" ]; then
    echo "Operación cancelada por el usuario."
    exit 0
fi

read -sp "🔑 Introduce la contraseña para el usuario de la base de datos '$DB_USER' (se creará de nuevo): " DB_PASS
echo
if [ -z "$DB_PASS" ]; then
    echo "❌ La contraseña no puede estar vacía. Abortando."
    exit 1
fi

echo "🧹 Paso 0.5: Limpiando instalación anterior..."
echo "   -> Buscando y eliminando servicios systemd antiguos..."
for service in $(systemctl list-unit-files | grep "^$APP_NAME" | cut -d' ' -f1); do
    echo "   -> Deteniendo y deshabilitando $service"
    systemctl stop "$service" || true
    systemctl disable "$service" || true
done
rm -f /etc/systemd/system/$APP_NAME*
systemctl daemon-reload
echo "   -> Servicios systemd limpiados."

echo "🟢 Paso 1: Instalando dependencias del sistema (PostgreSQL, Python, Gunicorn...)"
apt-get update
apt-get install -y wget ca-certificates postgresql postgresql-contrib python3-venv python3-pip python3-dev libpq-dev gunicorn

echo "🔥 Paso 2: Eliminando y recreando la base de datos y el usuario..."
sudo -u postgres psql -c "DROP DATABASE IF EXISTS $DB_NAME;"
sudo -u postgres psql -c "DROP USER IF EXISTS $DB_USER;"
echo "   -> Entidades de BD anteriores eliminadas."
sudo -u postgres psql -c "CREATE USER $DB_USER WITH PASSWORD '$DB_PASS';"
sudo -u postgres psql -c "CREATE DATABASE $DB_NAME OWNER $DB_USER;"
echo "✅ Base de datos y usuario recreados con éxito."

echo "🐍 Paso 3: Configurando el entorno de la aplicación..."
if ! id "$APP_USER" &>/dev/null; then
    echo "👤 Creando usuario del sistema '$APP_USER'..."
    sudo useradd -m -s /bin/bash "$APP_USER"
else
    echo "✅ Usuario del sistema '$APP_USER' ya existe."
fi
chown -R "$APP_USER":"$APP_USER" "$APP_DIR"

sudo -u "$APP_USER" bash <<EOF
set -e
cd "$APP_DIR"
echo "   -> Creando entorno virtual en $PYTHON_ENV"
rm -rf "$PYTHON_ENV"
python3 -m venv "$PYTHON_ENV"
echo "   -> Instalando dependencias desde requirements.txt..."
"$PYTHON_ENV/bin/python" -m pip install --upgrade pip
if [ -f "requirements.txt" ]; then
    "$PYTHON_ENV/bin/python" -m pip install -r "requirements.txt"
else
    echo "⚠️ ADVERTENCIA: No se encontró requirements.txt."
fi
EOF

echo "🧠 Paso 3.5: Descargando modelos de lenguaje para Newspaper3k..."
if [ -f "download_models.py" ]; then
    sudo -u "$APP_USER" "$PYTHON_ENV/bin/python" "$APP_DIR/download_models.py"
    echo "✅ Modelos NLP verificados/descargados."
else
    echo "⚠️ ADVERTENCIA: No se encontró download_models.py. El scraping de URLs puede fallar."
fi

echo "📐 Paso 4: Creando esquema de BD, configurando FTS y sembrando datos desde archivos .sql..."
export PGPASSWORD="$DB_PASS"

psql -U "$DB_USER" -h localhost -d "$DB_NAME" <<SQL
CREATE TABLE IF NOT EXISTS continentes (id SERIAL PRIMARY KEY, nombre VARCHAR(50) NOT NULL UNIQUE);
CREATE TABLE IF NOT EXISTS categorias (id SERIAL PRIMARY KEY, nombre VARCHAR(100) NOT NULL UNIQUE);
CREATE TABLE IF NOT EXISTS paises (id SERIAL PRIMARY KEY, nombre VARCHAR(100) NOT NULL UNIQUE, continente_id INTEGER REFERENCES continentes(id) ON DELETE SET NULL);
CREATE TABLE IF NOT EXISTS feeds (id SERIAL PRIMARY KEY, nombre VARCHAR(255), descripcion TEXT, url TEXT NOT NULL UNIQUE, categoria_id INTEGER REFERENCES categorias(id) ON DELETE SET NULL, pais_id INTEGER REFERENCES paises(id) ON DELETE SET NULL, idioma CHAR(2), activo BOOLEAN DEFAULT TRUE, fallos INTEGER DEFAULT 0, last_etag TEXT, last_modified TEXT);
CREATE TABLE IF NOT EXISTS fuentes_url (id SERIAL PRIMARY KEY, nombre VARCHAR(255) NOT NULL, url TEXT NOT NULL UNIQUE, categoria_id INTEGER REFERENCES categorias(id) ON DELETE SET NULL, pais_id INTEGER REFERENCES paises(id) ON DELETE SET NULL, idioma CHAR(2) DEFAULT 'es');
CREATE TABLE IF NOT EXISTS noticias (id VARCHAR(32) PRIMARY KEY, titulo TEXT, resumen TEXT, url TEXT NOT NULL UNIQUE, fecha TIMESTAMP, imagen_url TEXT, categoria_id INTEGER REFERENCES categorias(id) ON DELETE SET NULL, pais_id INTEGER REFERENCES paises(id) ON DELETE SET NULL, tsv tsvector);
ALTER TABLE noticias ADD COLUMN IF NOT EXISTS tsv tsvector;
CREATE OR REPLACE FUNCTION noticias_tsv_trigger() RETURNS trigger AS \$\$ BEGIN new.tsv := setweight(to_tsvector('spanish', coalesce(new.titulo,'')), 'A') || setweight(to_tsvector('spanish', coalesce(new.resumen,'')), 'B'); return new; END \$\$ LANGUAGE plpgsql;
DROP TRIGGER IF EXISTS tsvectorupdate ON noticias;
CREATE TRIGGER tsvectorupdate BEFORE INSERT OR UPDATE ON noticias FOR EACH ROW EXECUTE PROCEDURE noticias_tsv_trigger();
CREATE INDEX IF NOT EXISTS noticias_tsv_idx ON noticias USING gin(tsv);
SQL

echo "   -> Buscando archivos .sql para sembrar datos..."
if [ -f "continentes.sql" ]; then
    echo "   -> Cargando continentes.sql..."
    psql -U "$DB_USER" -h localhost -d "$DB_NAME" -f "continentes.sql"
fi
if [ -f "categorias.sql" ]; then
    echo "   -> Cargando categorias.sql..."
    psql -U "$DB_USER" -h localhost -d "$DB_NAME" -f "categorias.sql"
fi
if [ -f "paises.sql" ]; then
    echo "   -> Cargando paises.sql..."
    psql -U "$DB_USER" -h localhost -d "$DB_NAME" -f "paises.sql"
fi

echo "   -> Actualizando contadores de secuencias de la base de datos..."
psql -U "$DB_USER" -h localhost -d "$DB_NAME" <<SQL
SELECT setval('categorias_id_seq', (SELECT MAX(id) FROM categorias), true) WHERE (SELECT MAX(id) FROM categorias) IS NOT NULL;
SELECT setval('continentes_id_seq', (SELECT MAX(id) FROM continentes), true) WHERE (SELECT MAX(id) FROM continentes) IS NOT NULL;
SELECT setval('paises_id_seq', (SELECT MAX(id) FROM paises), true) WHERE (SELECT MAX(id) FROM paises) IS NOT NULL;
SQL

unset PGPASSWORD
echo "✅ Esquema de base de datos y datos iniciales configurados."

echo "👷 Paso 5: Creando script para el worker de captura..."
cat <<EOF > "$APP_DIR/worker.py"
import sys
import os
import logging
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
try:
    from app import app, fetch_and_store
except ImportError as e:
    logging.basicConfig()
    logging.critical(f"No se pudo importar la aplicación Flask. Error: {e}")
    sys.exit(1)
if __name__ == "__main__":
    with app.app_context():
        fetch_and_store()
EOF
chown "$APP_USER":"$APP_USER" "$APP_DIR/worker.py"
echo "✅ Script del worker creado/actualizado."

echo "⚙️ Paso 6: Creando nuevos archivos de servicio systemd..."
cat <<EOF > /etc/systemd/system/$APP_NAME.service
[Unit]
Description=Gunicorn instance to serve $APP_NAME
After=network.target
[Service]
User=$APP_USER
Group=$APP_USER
WorkingDirectory=$APP_DIR
Environment="PATH=$PYTHON_ENV/bin"
Environment="SECRET_KEY=$(python3 -c 'import os; print(os.urandom(24).hex())')"
Environment="DB_HOST=localhost"
Environment="DB_PORT=5432"
Environment="DB_NAME=$DB_NAME"
Environment="DB_USER=$DB_USER"
Environment="DB_PASS=$DB_PASS"
ExecStart=$PYTHON_ENV/bin/gunicorn --workers 3 --bind 0.0.0.0:$WEB_PORT $WSGI_APP_ENTRY
Restart=always
[Install]
WantedBy=multi-user.target
EOF

cat <<EOF > /etc/systemd/system/$APP_NAME-worker.service
[Unit]
Description=$APP_NAME Feed Fetcher Worker
After=postgresql.service
[Service]
Type=oneshot
User=$APP_USER
WorkingDirectory=$APP_DIR
Environment="SECRET_KEY=$(python3 -c 'import os; print(os.urandom(24).hex())')"
Environment="DB_HOST=localhost"
Environment="DB_PORT=5432"
Environment="DB_NAME=$DB_NAME"
Environment="DB_USER=$DB_USER"
Environment="DB_PASS=$DB_PASS"
ExecStart=$PYTHON_ENV/bin/python $APP_DIR/worker.py
EOF

cat <<EOF > /etc/systemd/system/$APP_NAME-worker.timer
[Unit]
Description=Run $APP_NAME worker every 15 minutes
[Timer]
OnBootSec=5min
OnUnitActiveSec=15min
Unit=$APP_NAME-worker.service
[Install]
WantedBy=timers.target
EOF
echo "✅ Archivos de servicio y timer creados."

echo "🚀 Paso 7: Recargando, habilitando, arrancando servicios y configurando firewall..."
systemctl daemon-reload
systemctl enable $APP_NAME.service
systemctl start $APP_NAME.service
systemctl enable $APP_NAME-worker.timer
systemctl start $APP_NAME-worker.timer

if command -v ufw &> /dev/null && ufw status | grep -q 'Status: active'; then
    echo "   -> Firewall UFW detectado. Abriendo puerto $WEB_PORT..."
    ufw allow $WEB_PORT/tcp
    ufw reload
fi

echo ""
echo "🎉 ¡REINSTALACIÓN COMPLETADA!"
echo "--------------------------------"
echo ""
echo "✅ La aplicación web está ahora accesible en:"
echo "   http://<IP_DE_TU_SERVIDOR>:$WEB_PORT"
echo ""
echo "Puedes verificar el estado de los servicios con:"
echo "sudo systemctl status $APP_NAME.service"
echo "sudo systemctl status $APP_NAME-worker.timer"
echo ""
echo "Para ver los logs de la aplicación web:"
echo "sudo journalctl -u $APP_NAME.service -f"