bot.py

"""Bot de Telegram para gestión del portfolio de trading.

Mejoras: HTML formatting, gráficas, heatmap de mercado, gestión de watchlist,
comparativas, y visualización completa.
"""
import io
import logging
import re
from datetime import datetime
from telegram import BotCommand, Update
from telegram.constants import ParseMode
from telegram.ext import (
    Application, CommandHandler, MessageHandler, ContextTypes, filters
)

import database as db
from analyzer import get_best_signal, quick_analysis, analyze_ticker
from portfolio import (
    execute_buy, execute_sell, get_portfolio_summary,
    check_stop_loss_take_profit, get_current_price
)
from tracker import tracker
from config import TELEGRAM_TOKEN, TELEGRAM_CHAT_ID
from traderepublic import tr_sync

logger = logging.getLogger(__name__)

# Mapeo de nombres a tickers
COMPANY_NAMES = {
    # Tech
    "apple": "AAPL", "microsoft": "MSFT", "google": "GOOGL",
    "alphabet": "GOOGL", "amazon": "AMZN", "nvidia": "NVDA",
    "meta": "META", "facebook": "META", "tesla": "TSLA",
    "amd": "AMD", "netflix": "NFLX", "salesforce": "CRM",
    "broadcom": "AVGO", "jpmorgan": "JPM", "visa": "V",
    "intel": "INTC", "ibm": "IBM", "oracle": "ORCL",
    "palantir": "PLTR", "uber": "UBER", "airbnb": "ABNB",
    "paypal": "PYPL", "shopify": "SHOP", "spotify": "SPOT",
    "disney": "DIS", "coca cola": "KO", "cocacola": "KO",
    "pepsi": "PEP", "walmart": "WMT", "boeing": "BA",
    "mastercard": "MA", "lockheed": "LMT", "lockheed martin": "LMT",
    "lockeed": "LMT", "lockeed martin": "LMT",
    "raytheon": "RTX", "northrop": "NOC", "northrop grumman": "NOC",
    "general dynamics": "GD", "general electric": "GE",
    "johnson": "JNJ", "johnson & johnson": "JNJ",
    "procter": "PG", "procter gamble": "PG",
    "exxon": "XOM", "exxonmobil": "XOM", "chevron": "CVX",
    "berkshire": "BRK-B", "warren buffett": "BRK-B",
    "costco": "COST", "starbucks": "SBUX", "nike": "NKE",
    "adobe": "ADBE", "qualcomm": "QCOM", "cisco": "CSCO",
    "repsol": "REP.MC", "inditex": "ITX.MC", "santander": "SAN.MC",
    "bbva": "BBVA.MC", "telefonica": "TEF.MC", "telefónica": "TEF.MC",
    "iberdrola": "IBE.MC", "endesa": "ELE.MC", "caixabank": "CABK.MC",
    "amadeus": "AMS.MC", "ferrovial": "FER.MC", "naturgy": "NTGY.MC",
    "mapfre": "MAP.MC", "acciona": "ANA.MC", "aena": "AENA.MC",
    # Commodities / Energía
    "petroleo": "USO", "petróleo": "USO", "crudo": "USO",
    "oil": "USO", "brent": "BNO", "wti": "USO",
    "oro": "GLD", "gold": "GLD",
    "plata": "SLV", "silver": "SLV",
    "gas": "UNG", "gas natural": "UNG",
    "cobre": "COPX", "copper": "COPX",
    # ETFs / Índices
    "spy": "SPY", "qqq": "QQQ", "nasdaq": "QQQ",
    "sp500": "SPY", "s&p": "SPY", "s&p500": "SPY",
    "dow": "DIA", "dow jones": "DIA",
    "russell": "IWM", "emergentes": "EEM",
    "europa": "VGK", "china": "FXI", "japon": "EWJ",
    # Energía empresas
    "shell": "SHEL", "bp": "BP", "total": "TTE",
    # Bancos
    "goldman": "GS",
    "morgan stanley": "MS", "bank of america": "BAC",
    # Crypto ETFs
    "bitcoin": "IBIT", "btc": "IBIT", "ethereum": "ETHA", "eth": "ETHA",
}

# Palabras a ignorar en español
IGNORE_WORDS = {
    "EL", "LA", "LOS", "LAS", "UN", "UNA", "DE", "DEL", "EN", "POR",
    "PARA", "CON", "QUE", "COMO", "MAS", "MENOS", "HOLA", "GRACIAS",
    "SI", "NO", "BUENO", "VALE", "OK", "BIEN", "MAL", "Y", "O",
    "MI", "TU", "SU", "ES", "AL", "SE", "LE", "LO", "ME", "TE",
    "HAY", "SOY", "VOY", "VER", "SER", "IR", "HAZ", "DI", "DA",
    "TODO", "TODOS", "TODAS", "MUCHO", "POCO", "ALGO", "NADA",
    "PUEDAS", "PUEDA", "PUEDE", "PUEDO", "MEJOR", "PEOR",
    "TAL", "MUY", "YA", "AUN", "HOY", "QUE", "MIS", "SUS", "TUS",
    "ADD", "DEL",
}


def extract_ticker(text: str) -> str | None:
    """Extrae un ticker del texto del usuario."""
    text_lower = text.lower().strip()

    for name, ticker in COMPANY_NAMES.items():
        if name in text_lower:
            return ticker

    words = text.upper().split()
    for word in words:
        clean = re.sub(r'[^A-Z]', '', word)
        if 1 <= len(clean) <= 5 and clean not in IGNORE_WORDS and clean.isalpha():
            return clean

    return None


def extract_multiple_tickers(text: str) -> list[str]:
    """Extrae múltiples tickers de un texto (para comparativas)."""
    tickers = []
    text_lower = text.lower().strip()

    for name, ticker in COMPANY_NAMES.items():
        if name in text_lower and ticker not in tickers:
            tickers.append(ticker)

    words = text.upper().split()
    for word in words:
        clean = re.sub(r'[^A-Z]', '', word)
        if 2 <= len(clean) <= 5 and clean not in IGNORE_WORDS and clean.isalpha():
            if clean not in tickers:
                tickers.append(clean)

    return tickers


def detect_intent(text: str) -> str:
    """Detecta la intención del mensaje."""
    text_lower = text.lower().strip()

    # Prioridad absoluta: prompt y comandos TR
    if text_lower.startswith("prompt"):
        return "prompt"
    if text_lower.startswith("tr "):
        if any(kw in text_lower for kw in ["conecta", "configura", "setup"]):
            return "tr_setup"
        if any(kw in text_lower for kw in ["confirma", "confirm", "código", "codigo"]):
            return "tr_confirm"
        if any(kw in text_lower for kw in ["portfolio", "cartera", "posiciones"]):
            return "tr_portfolio"

    intent_patterns = {
        "greet": ["hola", "buenas", "hey", "buenos días", "buenas tardes"],
        "thanks": ["gracias", "thx", "thanks", "genial", "perfecto"],
        "help": ["ayuda", "help", "qué puedes", "comandos", "opciones"],
        "demo": ["demo", "ejemplo", "tutorial", "enséñame", "enseñame"],
        "guide": ["guía", "guia", "cómo funciona", "como funciona",
                   "qué es esto", "que es esto", "explícame", "explicame",
                   "cómo analiza", "como analiza", "algoritmo", "metodología",
                   "metodologia", "métricas", "metricas", "indicadores"],
        "should_buy": ["compro?", "lo compro", "merece la pena", "es buen momento",
                        "debería comprar", "deberia comprar", "¿compro", "vale la pena",
                        "es buena idea", "qué opinas de", "que opinas de"],
        "confirmed_buy": ["he comprado", "compré", "compre", "acabo de comprar",
                           "ya compré", "ya compre", "metí", "meti",
                           "he metido", "acabo de meter"],
        "confirmed_sell": ["he vendido", "vendí", "vendi", "acabo de vender",
                            "ya vendí", "ya vendi", "he cerrado", "cerré", "cerre"],
        "portfolio": ["portfolio", "cartera", "resumen", "estado", "cómo voy",
                      "mis posiciones", "mi dinero", "balance"],
        "review_portfolio": ["revista", "revisa mi cartera", "revisa portfolio",
                            "cómo voy", "como voy", "qué hago", "que hago",
                            "analiza mi cartera", "analiza mi portfolio",
                            "qué vendo", "que vendo", "qué mantengo", "que mantengo"],
        "optimize_portfolio": ["optimiza", "optimizar", "mejora mi cartera",
                               "mejora portfolio", "rota", "rotación", "rotacion",
                               "alternativas", "algo mejor", "cambios"],
        "scan": ["escanea", "busca", "oportunidad", "señal", "scan",
                 "hay algo", "qué compro", "recomendación", "recomienda",
                 "analiza todo", "analiza todos", "todo lo que puedas"],
        "analyze": ["analiza", "análisis", "qué tal", "cómo está",
                    "información de", "info de", "mira"],
        "buy": ["compra", "comprar", "buy", "mete", "invierte"],
        "sell": ["vende", "vender", "sell", "cierra", "sal de"],
        "add_watch": ["añade", "añadir", "agrega", "agregar", "add"],
        "remove_watch": ["quita", "quitar", "elimina", "eliminar", "remove", "borra"],
        "watchlist": ["watchlist", "lista", "seguimiento", "vigilar"],
        "tracker": ["tracker", "precisión", "rendimiento", "estadísticas",
                    "cómo van las señales", "aciertos"],
        "history": ["historial", "operaciones", "trades", "cerradas"],
        "news": ["noticias", "sentimiento", "news", "sentiment",
                 "qué dicen", "prensa", "headlines"],
        "calendar": ["calendario", "eventos", "calendar", "fed",
                     "opec", "económico", "macro"],
        "market": ["mercado", "market", "heatmap", "mapa", "overview",
                   "vista general", "resumen mercado"],
        "compare": ["compara", "comparar", "compare", "vs", "versus"],
        "chart": ["gráfica", "grafica", "chart", "gráfico", "grafico",
                  "dibuja", "pinta"],
        "tr_sync": ["sincroniza", "sync", "trade republic", "tr sync",
                     "sincronizar"],
        "momentum": ["momentum", "rotación", "rotacion", "etfs", "rotation",
                     "portfolio mensual", "mensual", "rebalanceo"],
        "pead": ["pead", "earnings", "resultados empresa", "drift",
                 "post-earnings", "sorpresa earnings"],
        "regime": ["régimen", "regimen", "hmm", "estado mercado",
                   "bull bear", "mercado hmm"],
        "backtest": ["backtest", "backtesting", "prueba", "simula",
                     "simulación", "simulacion", "test estrategia"],
        "optimize": ["optimiza", "optimizar", "optimize", "mejores parámetros",
                      "mejores parametros", "grid search"],
        "ml_train": ["entrena", "entrenar", "train", "aprende", "aprender",
                      "entrenar modelo", "ml train"],
        "ml_predict": ["predice", "predicción", "prediccion", "predict",
                        "ml", "modelo", "qué dice el modelo"],
        "ml_approved": ["aprobados", "qué vigilas", "que vigilas", "qué miras",
                         "que miras", "tickers ml", "lista ml"],
        "alert_add": ["avísame cuando", "avisame cuando", "ponme alerta",
                      "pon alerta", "vigila ", "crea alerta", "nueva alerta",
                      "alerta para"],
        "alert_list": ["mis alertas", "alertas activas", "ver alertas",
                        "lista alertas"],
        "alert_remove": ["quita alerta", "elimina alerta", "cancela alerta",
                          "borra alerta", "remove alert", "deja de vigilar"],
        "invite": ["invitar", "invita", "invite", "código para", "codigo para",
                   "genera código", "genera codigo", "dar acceso", "dar de alta"],
        "kick_user": ["eliminar usuario", "elimina usuario", "quita usuario",
                       "expulsar", "expulsa", "kick", "dar de baja", "baja usuario",
                       "bloquear", "bloquea"],
        "users": ["usuarios", "users", "quién tiene acceso", "quien tiene acceso",
                  "invitados", "miembros"],
        "tr_setup": ["tr conecta", "tr configura", "tr setup",
                      "conecta trade republic", "conectar tr"],
        "tr_confirm": ["tr confirma", "tr confirm", "tr código", "tr codigo"],
        "tr_portfolio": ["tr portfolio", "tr cartera", "tr posiciones",
                         "portfolio tr", "cartera tr"],
        "prompt": ["prompt"],
    }

    # Primero: intents con keywords multi-palabra (más específicos)
    priority_intents = ["alert_add", "alert_remove", "alert_list", "kick_user"]
    for pi in priority_intents:
        if pi in intent_patterns:
            if any(kw in text_lower for kw in intent_patterns[pi]):
                return pi

    for intent, keywords in intent_patterns.items():
        if intent in priority_intents:
            continue
        if any(kw in text_lower for kw in keywords):
            return intent

    return "unknown"


# ===== HTML Formatters =====

def h(text: str) -> str:
    """Escapa HTML."""
    return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")


def format_portfolio_html(summary: dict) -> str:
    pnl_s = "+" if summary["pnl_total"] >= 0 else ""
    pnl_emoji = "🟢" if summary["pnl_total"] >= 0 else "🔴"

    msg = (
        f"<b>📊 Tu Cartera</b>\n\n"
        f"💰 Capital: <b>{summary['capital']:.2f}€</b>\n"
        f"📈 En posiciones: <b>{summary['portfolio_value']:.2f}€</b>\n"
        f"🏦 Valor total: <b>{summary['total_value']:.2f}€</b>\n"
        f"{pnl_emoji} P&amp;L: <b>{pnl_s}{summary['pnl_total']:.2f}€</b> "
        f"({pnl_s}{summary['pnl_pct']:.1f}%)\n"
    )

    if summary["positions"]:
        msg += "\n<b>Posiciones abiertas:</b>\n"
        for pos in summary["positions"]:
            pnl_s = "+" if pos["pnl"] >= 0 else ""
            emoji = "🟢" if pos["pnl"] >= 0 else "🔴"
            msg += (
                f"\n{emoji} <b>{h(pos['ticker'])}</b>: {pos['shares']}x\n"
                f"   📍 {pos['entry_price']:.2f} → {pos['current_price']:.2f}€\n"
                f"   💵 {pnl_s}{pos['pnl']:.2f}€ ({pnl_s}{pos['pnl_pct']:.1f}%)\n"
                f"   🛑 SL: {pos['stop_loss']:.2f} | 🎯 TP: {pos['take_profit']:.2f}\n"
            )
    else:
        msg += "\n<i>No hay posiciones abiertas</i>\n"

    if summary["total_trades"] > 0:
        wr_emoji = "✅" if summary["win_rate"] >= 0.7 else "⚠️"
        msg += (
            f"\n{wr_emoji} <b>Historial:</b> {summary['total_trades']} ops | "
            f"{summary['winning_trades']} ganadoras | "
            f"WR: {summary['win_rate']:.0%}\n"
        )

    t = summary["tracker"]
    if t["is_paused"]:
        msg += f"\n⛔ <b>Recomendador PAUSADO</b>\n<i>{h(t['pause_reason'])}</i>\n"
    elif t["window_stats"]["total"] > 0:
        ws = t["window_stats"]
        msg += f"\n🤖 Tracker: {ws['success']}/{ws['total']} ({ws['rate']:.0%})\n"

    return msg


def _currency_symbol(ticker: str) -> str:
    """Devuelve el símbolo de moneda según el ticker."""
    if any(ticker.endswith(suffix) for suffix in [".MC", ".L", ".PA", ".DE", ".AS"]):
        return "€"
    return "$"


def format_signal_html(signal) -> str:
    cur = _currency_symbol(signal.ticker)
    pnl_s = "+" if signal.expected_pnl >= 0 else ""
    action_emoji = "🟢 BUY" if signal.action == "BUY" else "🔴 SELL"
    conf_bar = "█" * int(signal.confidence * 10) + "░" * (10 - int(signal.confidence * 10))

    msg = (
        f"<b>{action_emoji} {h(signal.ticker)}</b>\n\n"
        f"📋 Estrategia: <code>{h(signal.strategy)}</code>\n"
        f"⚡ Score: <b>{signal.score:.1f}</b>/10\n"
        f"🎯 Confianza: [{conf_bar}] {signal.confidence:.0%}\n\n"
        f"📍 Entrada: <b>{signal.entry_price:.2f}{cur}</b>\n"
        f"🎯 Objetivo: <b>{signal.target_price:.2f}{cur}</b>\n"
        f"🛑 Stop-loss: <b>{signal.stop_loss:.2f}{cur}</b>\n"
        f"💵 P&amp;L esperado: <b>{pnl_s}{signal.expected_pnl:.2f}{cur}</b>\n"
        f"⚖️ R/R: <b>{signal.risk_reward:.2f}</b>\n"
    )

    # Mostrar tier de posición
    from config import POSITION_TIER_HIGH_SCORE, POSITION_TIER_HIGH_RR
    sig_score = abs(signal.score)
    if sig_score >= POSITION_TIER_HIGH_SCORE and signal.risk_reward >= POSITION_TIER_HIGH_RR:
        msg += f"💪 Posición: <b>30% capital</b> (señal fuerte)\n\n"
    else:
        msg += f"📊 Posición: <b>15% capital</b>\n\n"

    msg += f"<b>Razones:</b>\n"
    for r in signal.reasons:
        msg += f"  • {h(r)}\n"

    if signal.action == "BUY":
        msg += f"\n💡 <i>Para ejecutar: he comprado {h(signal.ticker)} a [precio]</i>"
    else:
        msg += f"\n💡 <i>Para ejecutar: he vendido {h(signal.ticker)} a [precio]</i>"
    return msg


def format_analysis_html(data: dict) -> str:
    """Formatea análisis en lenguaje claro para no-expertos."""
    if "error" in data:
        return f"❌ {h(data['error'])}"

    # Trend
    trend_info = {
        "ALCISTA": ("🟢", "Subiendo", "El precio lleva una racha positiva"),
        "BAJISTA": ("🔴", "Bajando", "El precio lleva una racha negativa"),
        "LATERAL": ("🟡", "Estable", "El precio no tiene dirección clara"),
    }
    trend_emoji, trend_text, trend_explain = trend_info.get(
        data["trend"], ("⚪", data["trend"], "")
    )

    # RSI en lenguaje simple
    rsi = data["rsi"]
    if rsi > 75:
        rsi_explain = "🔴 <b>Muy cara</b> — ha subido mucho y podría bajar pronto"
    elif rsi > 60:
        rsi_explain = "🟡 <b>Algo cara</b> — ha subido bastante"
    elif rsi < 25:
        rsi_explain = "🟢 <b>Muy barata</b> — ha caído mucho y podría rebotar"
    elif rsi < 40:
        rsi_explain = "🟡 <b>Algo barata</b> — ha bajado bastante"
    else:
        rsi_explain = "⚪ <b>Precio normal</b> — ni cara ni barata"

    # Volumen
    vol = data["vol_ratio"]
    if vol > 2.0:
        vol_explain = f"📢 <b>Mucha actividad</b> ({vol:.1f}x lo normal) — algo está pasando"
    elif vol > 1.3:
        vol_explain = f"📈 <b>Actividad alta</b> ({vol:.1f}x lo normal)"
    elif vol < 0.5:
        vol_explain = f"😴 <b>Poca actividad</b> ({vol:.1f}x lo normal) — poca gente operando"
    else:
        vol_explain = f"⚪ <b>Actividad normal</b> ({vol:.1f}x)"

    # MACD simplificado
    macd_diff = data["macd"] - data["macd_signal"]
    if macd_diff > 0 and data["macd"] > 0:
        macd_explain = "🟢 <b>Impulso positivo</b> — la fuerza compradora domina"
    elif macd_diff < 0 and data["macd"] < 0:
        macd_explain = "🔴 <b>Impulso negativo</b> — la fuerza vendedora domina"
    elif macd_diff > 0:
        macd_explain = "🟡 <b>Recuperándose</b> — empieza a mejorar"
    else:
        macd_explain = "🟡 <b>Debilitándose</b> — empieza a perder fuerza"

    cur = _currency_symbol(data['ticker'])
    msg = (
        f"<b>📊 {h(data['ticker'])}</b>\n\n"
        f"💲 Precio: <b>{data['price']:.2f}{cur}</b>\n"
        f"{trend_emoji} Tendencia: <b>{trend_text}</b> — {trend_explain}\n\n"
        f"<b>¿Qué dicen los indicadores?</b>\n"
        f"  {rsi_explain}\n"
        f"  {macd_explain}\n"
        f"  {vol_explain}\n"
    )

    if "sentiment" in data:
        score = data["sentiment_score"]
        if score > 0.1:
            sent_explain = "🟢 <b>Noticias positivas</b> — el mercado habla bien"
        elif score < -0.1:
            sent_explain = "🔴 <b>Noticias negativas</b> — hay preocupación"
        else:
            sent_explain = "⚪ <b>Noticias neutrales</b> — sin novedades importantes"
        msg += f"\n  {sent_explain}\n"
        if data.get("high_impact_news"):
            msg += "  ⚠️ <b>¡Hay noticias de ALTO IMPACTO!</b>\n"
        if data.get("top_headlines"):
            msg += "\n<b>Titulares:</b>\n"
            for hl in data["top_headlines"][:3]:
                msg += f"  • <i>{h(hl[:80])}</i>\n"

    if data.get("calendar_events"):
        msg += f"\n📅 <b>Eventos próximos</b> (riesgo {h(data['calendar_risk'])}):\n"
        for e in data["calendar_events"]:
            msg += f"  • {h(e)}\n"

    return msg


def format_tracker_html(status: dict) -> str:
    ws = status["window_stats"]

    if status["is_paused"]:
        msg = f"⛔ <b>Tracker PAUSADO</b>\n<i>Hasta: {h(str(status['paused_until']))}</i>\n<i>{h(status['pause_reason'])}</i>\n\n"
    else:
        msg = "✅ <b>Tracker Activo</b>\n\n"

    if ws["total"] > 0:
        wr = ws["rate"]
        bar = "█" * int(wr * 10) + "░" * (10 - int(wr * 10))
        msg += (
            f"<b>Últimas {ws['total']} operaciones:</b>\n"
            f"  ✅ Exitosas: {ws['success']}\n"
            f"  ❌ Fallidas: {ws['failed']}\n"
            f"  [{bar}] {wr:.0%}\n\n"
        )

    if status["strategies"]:
        msg += "<b>Estrategias:</b>\n"
        for name, info in status["strategies"].items():
            state_emoji = "✅" if info["active"] else "⛔"
            rate_emoji = "🟢" if info["rate"] >= 0.7 else "🟡" if info["rate"] >= 0.5 else "🔴"
            pnl_s = "+" if info["avg_pnl"] >= 0 else ""
            msg += (
                f"\n{state_emoji} <b>{h(name)}</b>\n"
                f"  {rate_emoji} {info['success']}/{info['total']} ({info['rate']:.0%})\n"
                f"  💵 P&amp;L medio: {pnl_s}{info['avg_pnl']:.2f}€\n"
            )

    return msg


# ===== Message Handler =====

async def send_html(update_or_chat, text: str, app=None):
    """Envía mensaje con HTML parsing."""
    try:
        if hasattr(update_or_chat, 'message'):
            await update_or_chat.message.reply_text(text, parse_mode=ParseMode.HTML)
            # Log outgoing
            chat_id = str(update_or_chat.effective_chat.id)
            clean = re.sub(r'<[^>]+>', '', text)
            db.log_chat(chat_id, "bot", "out", clean[:2000])
        elif app:
            await app.bot.send_message(chat_id=update_or_chat, text=text, parse_mode=ParseMode.HTML)
            clean = re.sub(r'<[^>]+>', '', text)
            db.log_chat(str(update_or_chat), "bot", "out", clean[:2000])
    except Exception as e:
        # Fallback sin HTML si falla el parsing
        logger.warning(f"Error enviando HTML, fallback a texto plano: {e}")
        clean = re.sub(r'<[^>]+>', '', text)
        if hasattr(update_or_chat, 'message'):
            await update_or_chat.message.reply_text(clean)
        elif app:
            await app.bot.send_message(chat_id=update_or_chat, text=clean)


async def send_photo(update, photo_bytes: bytes, caption: str = ""):
    """Envía una imagen al chat."""
    try:
        await update.message.reply_photo(
            photo=io.BytesIO(photo_bytes),
            caption=caption,
            parse_mode=ParseMode.HTML
        )
        # Guardar media y loguear
        chat_id = str(update.effective_chat.id)
        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
        media_path = db.save_media(photo_bytes, f"chart_{ts}.png")
        clean_caption = re.sub(r'<[^>]+>', '', caption) if caption else ""
        db.log_chat(chat_id, "bot", "out", clean_caption, message_type="photo", media_path=media_path)
    except Exception as e:
        logger.error(f"Error enviando foto: {e}")
        await update.message.reply_text("Error generando la imagen.")


async def _check_auth(update: Update, context: ContextTypes.DEFAULT_TYPE) -> bool:
    """Verifica autorización. Retorna True si autorizado."""
    chat_id = str(update.effective_chat.id)
    if db.is_authorized_user(chat_id):
        return True

    text = (update.message.text or "").strip().upper()
    if text.startswith("BOLSA-") and len(text) <= 12:
        user = update.effective_user
        name = user.first_name or user.username or "invitado"
        if db.redeem_invite_code(text, chat_id, name):
            await update.message.reply_text(
                f"✅ ¡Bienvenido {name}! Tu código ha sido activado.\n\n"
                "Ahora recibirás las alertas del bot.\n"
                "Escribe /ayuda para ver lo que puedo hacer.",
                parse_mode=ParseMode.HTML
            )
            try:
                await context.bot.send_message(
                    chat_id=TELEGRAM_CHAT_ID,
                    text=f"👤 <b>Nuevo usuario:</b> {h(name)} se ha unido con código <code>{h(text)}</code>",
                    parse_mode=ParseMode.HTML
                )
            except Exception:
                pass
        else:
            await update.message.reply_text("❌ Código inválido o ya usado.")
    else:
        await update.message.reply_text(
            "🔒 Bot privado. Necesitas un código de invitación.\n"
            "Envía tu código aquí para activar el acceso."
        )
    return False


async def _analyze_full(update: Update, ticker: str):
    """Análisis completo unificado: gráfica + veredicto + explicación clara.

    Combina análisis técnico, ML, sentimiento y LLM en un solo mensaje
    pensado para alguien sin formación bursátil.
    """
    await send_html(update, f"🔍 <i>Analizando {h(ticker)}...</i>")

    # Gráfica técnica
    try:
        from charts import chart_technical_analysis
        chart = chart_technical_analysis(ticker)
        if chart:
            await send_photo(update, chart, f"📈 <b>{h(ticker)}</b>")
    except Exception as e:
        logger.debug(f"Chart unavailable for {ticker}: {e}")

    # Recoger señales para el veredicto
    capital = db.get_capital()
    reasons_pro = []
    reasons_con = []
    score_total = 0

    # ML
    ml_prob = 0
    try:
        from ml_model import predict_signal
        pred = predict_signal(ticker)
        if pred:
            ml_prob = pred["probability"]
            if ml_prob >= 0.65:
                score_total += 2
                reasons_pro.append(
                    f"La inteligencia artificial detecta oportunidad ({ml_prob:.0%} probabilidad de subida)"
                )
            elif ml_prob < 0.45:
                score_total -= 2
                reasons_con.append(
                    f"La inteligencia artificial no ve oportunidad ({ml_prob:.0%} probabilidad)"
                )
    except Exception:
        pass

    # Análisis técnico (estrategias)
    signals = analyze_ticker(ticker, capital)
    best_signal = None
    if signals:
        best_signal = signals[0]
        if best_signal.action == "BUY" and best_signal.score >= 5:
            score_total += 2
            reasons_pro.append(
                f"Los indicadores técnicos son positivos (puntuación {best_signal.score:.1f}/10)"
            )
        elif best_signal.action == "SELL" or best_signal.score < 0:
            score_total -= 2
            reasons_con.append(
                f"Los indicadores técnicos son negativos (puntuación {best_signal.score:.1f}/10)"
            )

    # Datos de mercado + tendencia
    data = quick_analysis(ticker)
    if "error" not in data:
        if data["trend"] == "ALCISTA":
            score_total += 1
            reasons_pro.append("La acción lleva una racha positiva (tendencia alcista)")
        elif data["trend"] == "BAJISTA":
            score_total -= 1
            reasons_con.append("La acción lleva una racha negativa (tendencia bajista)")

        if data["rsi"] > 75:
            score_total -= 1
            reasons_con.append(
                "Ha subido demasiado rápido y podría corregir pronto (sobrecomprada)"
            )
        elif data["rsi"] < 30:
            score_total += 1
            reasons_pro.append(
                "Ha caído mucho y podría rebotar pronto (sobrevendida)"
            )

        if data.get("sentiment") and data.get("sentiment_score", 0) < -0.1:
            reasons_con.append("Las noticias recientes son negativas")
        elif data.get("sentiment") and data.get("sentiment_score", 0) > 0.1:
            reasons_pro.append("Las noticias recientes son positivas")

        if data.get("high_impact_news"):
            reasons_con.append(
                "⚠️ Hay noticias de alto impacto — el precio puede moverse mucho"
            )

        if data.get("calendar_events"):
            reasons_con.append(
                f"Hay eventos económicos próximos ({data['calendar_risk']})"
            )

    # Veredicto claro
    if score_total >= 3:
        emoji = "🟢"
        veredicto = "SÍ, buen momento para comprar"
        explicacion = "Varios indicadores apuntan a que puede subir."
    elif score_total >= 1:
        emoji = "🟡"
        veredicto = "Puede, pero no es la mejor entrada"
        explicacion = "Hay señales mixtas. Si compras, hazlo con precaución."
    elif score_total >= -1:
        emoji = "🟡"
        veredicto = "Mejor esperar un poco"
        explicacion = "No hay suficientes señales positivas ahora mismo."
    else:
        emoji = "🔴"
        veredicto = "NO, ahora mismo no es buena idea"
        explicacion = "Los indicadores sugieren que puede seguir bajando."

    # Construir mensaje principal
    cur = _currency_symbol(ticker)
    price = data.get("price", 0) if "error" not in data else 0

    msg = f"{emoji} <b>{veredicto}</b>\n"
    msg += f"<i>{explicacion}</i>\n\n"

    if price:
        msg += f"💲 Precio actual: <b>{price:.2f}{cur}</b>\n\n"

    if reasons_pro:
        msg += "<b>✅ A favor:</b>\n"
        for r in reasons_pro:
            msg += f"  • {h(r)}\n"
        msg += "\n"
    if reasons_con:
        msg += "<b>❌ En contra:</b>\n"
        for r in reasons_con:
            msg += f"  • {h(r)}\n"
        msg += "\n"

    # Resumen de indicadores (simplificado)
    if "error" not in data:
        msg += format_analysis_html(data)
        msg += "\n"

    # Niveles de precio sugeridos
    if best_signal and best_signal.action == "BUY":
        msg += (
            f"\n<b>📌 Si decides comprar:</b>\n"
            f"  🛑 Vende si baja a <b>{best_signal.stop_loss:.2f}{cur}</b> (limitar pérdidas)\n"
            f"  🎯 Objetivo de venta: <b>{best_signal.take_profit:.2f}{cur}</b>\n"
        )
    elif price and "error" not in data:
        atr = data.get("atr", 0)
        if atr > 0:
            sl = price - (2.0 * atr)
            tp = price + (3.0 * atr)
            msg += (
                f"\n<b>📌 Si decides comprar:</b>\n"
                f"  🛑 Vende si baja a <b>{sl:.2f}{cur}</b> (limitar pérdidas)\n"
                f"  🎯 Objetivo de venta: <b>{tp:.2f}{cur}</b>\n"
            )

    msg += f"\n💡 <i>Si compras, dime: he comprado {h(ticker)} a [precio]</i>"

    # LLM: explicación narrativa en lenguaje sencillo
    try:
        from ollama import analyze_should_buy
        llm_analysis = analyze_should_buy(
            ticker=ticker,
            score=score_total,
            reasons_pro=reasons_pro,
            reasons_con=reasons_con,
            ml_prob=ml_prob,
            trend=data.get("trend", "LATERAL") if "error" not in data else "N/A",
            rsi=data.get("rsi", 50) if "error" not in data else 50,
            sentiment=data.get("sentiment", "Sin datos") if "error" not in data else "Sin datos",
        )
        if llm_analysis:
            msg += f"\n\n🧠 <b>Explicación:</b>\n<i>{h(llm_analysis)}</i>"
    except Exception as e:
        logger.debug(f"LLM analysis unavailable for {ticker}: {e}")

    await send_html(update, msg)


async def _dispatch_intent(update: Update, context: ContextTypes.DEFAULT_TYPE, text: str):
    """Procesa un texto despachando por intent."""
    intent = detect_intent(text)

    try:
        if intent == "greet":
            await send_html(update,
                "👋 <b>Hola!</b> Soy tu asistente de trading.\n\n"
                "Puedo analizar acciones, gestionar tu cartera, "
                "buscar oportunidades y mostrarte gráficas.\n\n"
                "Escribe /ayuda o usa el menú de comandos (/) para ver todo."
            )

        elif intent == "thanks":
            await send_html(update, "😊 De nada! Aquí estoy para lo que necesites.")

        elif intent == "demo":
            # Paso 1
            await send_html(update,
                "📖 <b>Cómo funciona el bot — Ejemplo completo</b>\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"
                "Imagina que estás pensando en comprar Apple.\n\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
                "📝 <b>PASO 1: Preguntar</b>\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"
                "Tú escribes:\n"
                "  <code>¿compro Apple?</code>\n\n"
                "El bot responde:\n\n"
                "🟢 <b>SÍ, buen momento para comprar</b>\n\n"
                "<b>A favor:</b>\n"
                "  ✅ El modelo ML dice que sí (84% probabilidad)\n"
                "  ✅ Tendencia alcista\n"
                "  ✅ Noticias positivas\n\n"
                "<b>En contra:</b>\n"
                "  ❌ Sobrecomprado (RSI 72)\n\n"
                "💲 Precio actual: <b>195.20€</b>\n"
                "💡 <i>Si compras, dime: he comprado AAPL a 195</i>"
            )

            import asyncio
            await asyncio.sleep(2)

            # Paso 2
            await send_html(update,
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
                "📝 <b>PASO 2: Confirmar compra</b>\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"
                "Compras en tu broker (Trade Republic, etc).\n"
                "Luego escribes:\n"
                "  <code>he comprado AAPL a 195</code>\n\n"
                "El bot responde:\n\n"
                "✅ <b>Registrado!</b>\n\n"
                "📌 <b>AAPL</b> comprado a <b>195.00€</b>\n\n"
                "Te avisaré:\n"
                "  🛑 Vende si baja a <b>188.40€</b> (-3.4%)\n"
                "  🎯 Vende si sube a <b>204.90€</b> (+5.1%)\n\n"
                "<i>Reviso tu posición cada 2 horas y te aviso.</i>"
            )

            await asyncio.sleep(2)

            # Paso 3
            await send_html(update,
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
                "📝 <b>PASO 3: El bot te vigila</b>\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"
                "Cada 2 horas recibes un mensaje:\n\n"
                "🟡 <b>AAPL: +0.8%</b>\n"
                "Estable. Nada que hacer por ahora.\n"
                "SL en 188.40€ | TP en 204.90€\n"
                "💲 Precio actual: <b>196.56€</b>\n\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"
                "Al día siguiente:\n\n"
                "🟢 <b>AAPL: +3.2%</b>\n"
                "En positivo. El trailing stop te protege.\n"
                "Objetivo: 204.90€ (falta 1.9%). Aguanta.\n"
                "💲 Precio actual: <b>201.24€</b>"
            )

            await asyncio.sleep(2)

            # Paso 4
            await send_html(update,
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
                "📝 <b>PASO 4: El bot te avisa</b>\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"
                "Si las cosas van bien:\n\n"
                "🟢 <b>AAPL: +5.1%</b>\n"
                "Vas muy bien. Casi en objetivo (204.90€).\n"
                "<b>Si quieres asegurar beneficio, puedes vender ya.</b>\n\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"
                "Si las cosas van mal:\n\n"
                "🔴 <b>AAPL: -4.2%</b>\n"
                "Muy cerca del stop-loss (188.40€).\n"
                "<b>Valora vender para limitar pérdidas.</b>\n\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"
                "🎯 <b>Resumen: tú decides, el bot te informa.</b>\n\n"
                "Si vendes, confirma: <code>he vendido AAPL a 205</code>\n\n"
                "Pruébalo ahora con:\n"
                "  <code>¿compro Apple?</code>"
            )

        elif intent == "should_buy":
            ticker = extract_ticker(text)
            if not ticker:
                await send_html(update, "❓ ¿Qué acción? Ejemplo: <b>¿compro Apple?</b>")
                return
            await _analyze_full(update, ticker)

        elif intent == "confirmed_buy":
            ticker = extract_ticker(text)
            if not ticker:
                await send_html(update, "❓ ¿Qué compraste? Ejemplo: <b>he comprado AAPL a 195</b>")
                return

            # Extraer precio del texto
            import re as _re
            price_match = _re.search(r'(\d+[.,]?\d*)\s*[€$]?', text.split(ticker if ticker in text.upper() else '')[-1])
            if not price_match:
                # Intentar con el precio del texto completo
                numbers = _re.findall(r'(\d+[.,]\d+|\d{2,})', text)
                if numbers:
                    entry_price = float(numbers[-1].replace(',', '.'))
                else:
                    # Usar precio actual
                    entry_price = get_current_price(ticker)
                    if not entry_price:
                        await send_html(update, f"❓ ¿A qué precio compraste? Dime: <b>he comprado {h(ticker)} a [precio]</b>")
                        return
            else:
                entry_price = float(price_match.group(1).replace(',', '.'))

            # Calcular SL/TP dinámicos
            from portfolio import get_atr
            atr = get_atr(ticker)
            if atr and atr > 0:
                stop_loss = entry_price - (2.0 * atr)
                take_profit = entry_price + (3.0 * atr)
            else:
                stop_loss = entry_price * 0.95
                take_profit = entry_price * 1.10

            # Registrar en DB
            pos_id = db.open_position(
                ticker=ticker, shares=1, entry_price=entry_price,
                stop_loss=stop_loss, take_profit=take_profit,
                commission=0  # Comisión real ya la paga el usuario en su broker
            )

            sl_pct = ((stop_loss - entry_price) / entry_price) * 100
            tp_pct = ((take_profit - entry_price) / entry_price) * 100

            cur = _currency_symbol(ticker)
            msg = (
                f"✅ <b>Registrado!</b>\n\n"
                f"📌 <b>{h(ticker)}</b> comprado a <b>{entry_price:.2f}{cur}</b>\n\n"
                f"Te avisaré:\n"
                f"  🛑 Vende si baja a <b>{stop_loss:.2f}{cur}</b> ({sl_pct:.1f}%)\n"
                f"  🎯 Vende si sube a <b>{take_profit:.2f}{cur}</b> (+{tp_pct:.1f}%)\n\n"
                f"<i>Reviso tu posición cada 2 horas y te aviso.</i>"
            )
            await send_html(update, msg)

        elif intent == "confirmed_sell":
            ticker = extract_ticker(text)
            if not ticker:
                await send_html(update, "❓ ¿Qué vendiste? Ejemplo: <b>he vendido AAPL a 200</b>")
                return

            # Extraer precio del texto
            import re as _re
            price_match = _re.search(r'(\d+[.,]?\d*)\s*[€$]?', text.split(ticker if ticker in text.upper() else '')[-1])
            if not price_match:
                numbers = _re.findall(r'(\d+[.,]\d+|\d{2,})', text)
                if numbers:
                    sell_price = float(numbers[-1].replace(',', '.'))
                else:
                    sell_price = get_current_price(ticker)
                    if not sell_price:
                        await send_html(update, f"❓ ¿A qué precio vendiste? Dime: <b>he vendido {h(ticker)} a [precio]</b>")
                        return
            else:
                sell_price = float(price_match.group(1).replace(',', '.'))

            # Buscar posición abierta
            pos = db.get_position_by_ticker(ticker)
            if not pos:
                await send_html(update, f"❌ No tengo registrada una posición abierta en <b>{h(ticker)}</b>")
                return

            entry_price = pos["entry_price"]
            shares = pos["shares"]
            pnl = (sell_price - entry_price) * shares
            pnl_pct = ((sell_price - entry_price) / entry_price) * 100
            pnl_emoji = "🟢" if pnl >= 0 else "🔴"
            pnl_sign = "+" if pnl >= 0 else ""

            db.close_position(pos["id"], sell_price, pnl)

            cur = _currency_symbol(ticker)
            msg = (
                f"{pnl_emoji} <b>{h(ticker)}</b>\n\n"
                f"📍 {entry_price:.2f} → {sell_price:.2f}{cur}\n"
                f"💵 {pnl_sign}{pnl:.2f}{cur} ({pnl_sign}{pnl_pct:.1f}%)\n\n"
                f"<i>Resultado registrado. Esto me ayuda a mejorar.</i>"
            )
            await send_html(update, msg)

        elif intent == "help":
            await send_html(update,
                "<b>📖 Qué puedo hacer:</b>\n\n"
                "<b>🚦 Lo básico</b>\n"
                "  /ejemplo → Tutorial paso a paso\n"
                "  <code>¿compro Apple?</code> → Semáforo 🟢🟡🔴\n"
                "  <code>he comprado AAPL a 195</code> → Registro + alertas\n"
                "  <code>he vendido AAPL a 200</code> → Cierre + P&amp;L\n\n"
                "<b>📊 Mi cartera</b>\n"
                "  /portfolio → Posiciones abiertas\n"
                "  /historial → Operaciones cerradas\n"
                "  /revista → Análisis: vender/mantener/añadir\n"
                "  <code>optimiza</code> → Sugerir rotación\n\n"
                "<b>🔍 Mercado</b>\n"
                "  /escanear → Buscar oportunidades\n"
                "  /mercado → Heatmap general\n"
                "  /analiza <code>AAPL</code> → Análisis técnico\n"
                "  /noticias <code>AAPL</code> → Sentimiento\n"
                "  /calendario → Eventos económicos\n"
                "  <code>compara AAPL MSFT</code> → Comparativa\n\n"
                "<b>🔬 Avanzado</b>\n"
                "  /backtest <code>AAPL</code> → Simular estrategias\n"
                "  <code>predice AAPL</code> → Predicción ML\n"
                "  /regimen → Estado mercado (bull/bear)\n"
                "  <code>momentum</code> → Rotación ETFs mensual\n"
                "  <code>earnings</code> → Oportunidades PEAD\n\n"
                "<b>⚙️ Gestión</b>\n"
                "  /watchlist → Ver lista\n"
                "  <code>añade AAPL</code> · <code>quita AAPL</code>\n"
                "  /alertas → Alertas activas\n"
                "  <code>avísame cuando AAPL</code> → Nueva alerta\n"
                "  /tracker → Precisión del bot\n\n"
                "<b>🏦 Trade Republic</b>\n"
                "  <code>tr conecta</code> · <code>tr portfolio</code> · <code>sincroniza</code>\n\n"
                "<b>👥 Usuarios</b> (admin)\n"
                "  <code>invitar Eduardo</code> · <code>usuarios</code> · <code>eliminar usuario</code>\n\n"
                "💬 <i>Usa el menú / o escríbeme en lenguaje natural.</i>"
            )

        elif intent == "guide":
            # Parte 1: Qué es y cómo funciona
            await send_html(update,
                "📖 <b>GUÍA DEL BOT DE TRADING</b>\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"

                "🤖 <b>¿Qué es?</b>\n"
                "Un bot que analiza acciones del mercado americano y europeo "
                "usando análisis técnico + inteligencia artificial. "
                "Te dice cuándo comprar, cuándo vender, y vigila tus posiciones "
                "para que no tengas que estar mirando la pantalla.\n\n"

                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
                "🚦 <b>EL SEMÁFORO</b>\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"

                "Preguntas <i>\"¿compro Apple?\"</i> y el bot responde:\n\n"
                "🟢 <b>SÍ</b> — Buen momento, las métricas están alineadas\n"
                "🟡 <b>PUEDE</b> — No es ideal, mejor esperar\n"
                "🔴 <b>NO</b> — Ahora mismo es mala idea\n\n"

                "Si decides comprar, dices <i>\"he comprado AAPL a 195\"</i> "
                "y el bot registra tu posición. A partir de ahí te vigila "
                "automáticamente y te avisa si tienes que vender.\n\n"

                "Escribe <b>ejemplo</b> para ver el flujo completo paso a paso."
            )

            # Parte 2: Estrategias
            await send_html(update,
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
                "📊 <b>LAS 4 ESTRATEGIAS</b>\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"

                "El bot usa 4 estrategias diferentes y elige la mejor "
                "según el estado del mercado:\n\n"

                "1️⃣ <b>Momentum Breakout</b> (principal)\n"
                "Detecta cuando una acción rompe su máximo de 20 días "
                "con volumen alto. Como un caballo que se escapa — "
                "si rompe la valla con fuerza, probablemente siga corriendo.\n"
                "<i>RSI 50-75 + MACD creciente + volumen alto</i>\n\n"

                "2️⃣ <b>EMA Crossover</b>\n"
                "Cruces de medias móviles (9/21/50 días). Cuando la media "
                "rápida cruza por encima de la lenta = tendencia alcista.\n"
                "<i>Solo se activa en mercados con tendencia clara</i>\n\n"

                "3️⃣ <b>RSI + MACD</b>\n"
                "Combina tres indicadores de momentum. Busca que todos "
                "apunten en la misma dirección.\n"
                "<i>RSI + MACD + Stochastic alineados</i>\n\n"

                "4️⃣ <b>Mean Reversion</b>\n"
                "Compra cuando el precio cae mucho y toca la banda "
                "inferior de Bollinger. La idea: lo que baja mucho "
                "tiende a rebotar al centro.\n"
                "<i>Solo en mercados laterales, no en tendencias</i>"
            )

            # Parte 3: Indicadores
            await send_html(update,
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
                "📈 <b>INDICADORES QUE USA</b>\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"

                "📍 <b>RSI</b> (Relative Strength Index)\n"
                "Mide si algo está sobrecomprado (&gt;70) o sobrevendido (&lt;30). "
                "Como un termómetro de codicia/miedo.\n\n"

                "📍 <b>MACD</b>\n"
                "Mide el impulso. Cuando cruza al alza = el momentum sube. "
                "Cuando cruza a la baja = se está frenando.\n\n"

                "📍 <b>Stochastic</b>\n"
                "Parecido al RSI pero más sensible a corto plazo. "
                "Detecta giros rápidos.\n\n"

                "📍 <b>Bollinger Bands</b>\n"
                "Bandas de volatilidad. El precio suele moverse dentro. "
                "Si toca la banda inferior, posible rebote. Si toca la superior, "
                "posible corrección.\n\n"

                "📍 <b>EMA</b> (Exponential Moving Average)\n"
                "Media del precio de los últimos X días. Usamos 9, 21 y 50 días. "
                "Si EMA9 &gt; EMA21 &gt; EMA50 = tendencia alcista.\n\n"

                "📍 <b>ATR</b> (Average True Range)\n"
                "Mide cuánto se mueve una acción por día. "
                "Se usa para calcular los stop-loss y take-profit.\n\n"

                "📍 <b>Volumen</b>\n"
                "Cuántas acciones se negocian. Volumen alto confirma "
                "los movimientos. Volumen bajo = movimiento dudoso."
            )

            # Parte 4: Pipeline y filtros
            await send_html(update,
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
                "🔬 <b>EL PIPELINE DE FILTROS</b>\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"

                "Cada señal pasa por 6 filtros antes de llegar a ti:\n\n"

                "1️⃣ <b>Multiframe</b> — ¿La tendencia semanal confirma?\n"
                "2️⃣ <b>Volumen</b> — ¿Hay dinero real detrás?\n"
                "3️⃣ <b>Régimen</b> — ¿El mercado está en tendencia o lateral?\n"
                "4️⃣ <b>SPY</b> — ¿El mercado general sube o baja?\n"
                "5️⃣ <b>Sentimiento</b> — ¿Qué dicen las noticias?\n"
                "6️⃣ <b>Calendario</b> — ¿Hay eventos macro que afecten?\n\n"

                "Solo las señales que superan TODO esto llegan a ti.\n\n"

                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
                "🧠 <b>INTELIGENCIA ARTIFICIAL</b>\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"

                "Además del análisis técnico, un modelo de ML "
                "(GradientBoosting) evalúa cada acción con 19 métricas. "
                "El modelo se entrena con datos históricos y predice "
                "si una acción subirá +5% en los próximos 10 días.\n\n"

                "El modelo dice NO la mayoría del tiempo (~81%). "
                "Solo aprueba las señales con alta probabilidad. "
                "Se re-entrena cada domingo automáticamente."
            )

            # Parte 5: Gestión de riesgo
            await send_html(update,
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
                "🛡️ <b>GESTIÓN DEL RIESGO</b>\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"

                "📌 <b>Stop-Loss (SL)</b>\n"
                "Precio al que vendemos para cortar pérdidas. "
                "Se calcula con 2×ATR. Si una acción se mueve $5/día "
                "de media, el SL se pone a $10 por debajo.\n\n"

                "📌 <b>Take-Profit (TP)</b>\n"
                "Precio objetivo. Se calcula con 3×ATR.\n\n"

                "📌 <b>Trailing Stop</b>\n"
                "El SL sube automáticamente cuando la acción sube. "
                "Si compras a 100 y sube a 120, el SL sube también. "
                "Así proteges ganancias sin vender demasiado pronto.\n\n"

                "📌 <b>Tamaño de posición</b>\n"
                "Señales top (score ≥7): hasta 30% del capital\n"
                "Señales normales: 15% del capital\n"
                "Máximo 3 posiciones abiertas a la vez\n\n"

                "📌 <b>Ratio Riesgo/Beneficio</b>\n"
                "Solo entramos si el beneficio potencial es al menos "
                "1.5× la pérdida potencial. Si arriesgas 10€, "
                "el objetivo mínimo es ganar 15€.\n\n"

                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
                "⏰ <b>VIGILANCIA AUTOMÁTICA</b>\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"

                "El bot trabaja L-V durante horario de mercado (15:30-22:00):\n\n"
                "• Cada 15 min → busca oportunidades\n"
                "• Cada 5 min → revisa tus SL/TP\n"
                "• Cada 30 min → revisa tus alertas personalizadas\n"
                "• 16:00, 18:00, 20:00 → te dice cómo van tus posiciones\n"
                "• 22:15 → resumen del día\n\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"
                "🔔 <b>ALERTAS PERSONALIZADAS</b>\n"
                "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n"
                "Puedes pedir que el bot vigile una acción concreta:\n\n"
                "<code>avísame cuando AAPL esté para comprar</code>\n\n"
                "El bot analiza cada 30 min y te avisa cuando el score sube:\n"
                "🟡 Score 3-4 → \"Se está calentando\"\n"
                "🟢 Score ≥5 → \"¡Momento de comprar!\" + gráfica + SL/TP\n\n"
                "Máximo 1 aviso verde y 1 amarillo al día por ticker.\n\n"
                "Escribe <b>ayuda</b> para ver todos los comandos."
            )

        elif intent == "portfolio":
            summary = get_portfolio_summary()
            await send_html(update, format_portfolio_html(summary))

            # Enviar gráfica de distribución
            from charts import chart_portfolio_distribution
            chart = chart_portfolio_distribution(summary["positions"], summary["capital"])
            if chart:
                await send_photo(update, chart, "📊 Distribución del portfolio")

        elif intent == "review_portfolio":
            await send_html(update, "🔍 <i>Analizando tu cartera completa...</i>")

            positions = db.get_open_positions()
            if not positions:
                await send_html(update, "📭 No tienes posiciones abiertas.")
                return

            capital = db.get_capital()
            sells = []
            holds = []
            buys_more = []

            for pos in positions:
                pos = dict(pos)
                ticker = pos["ticker"]
                if ticker.startswith("_"):
                    continue

                price = get_current_price(ticker)
                if price is None:
                    continue

                entry = pos["entry_price"]
                pnl_pct = ((price - entry) / entry) * 100
                shares = pos["shares"]
                value = price * shares

                # Analizar señales
                signals = analyze_ticker(ticker, capital)
                best = signals[0] if signals else None

                # Quick analysis para tendencia
                data = quick_analysis(ticker)
                trend = data.get("trend", "LATERAL") if "error" not in data else "?"
                rsi = data.get("rsi", 50) if "error" not in data else 50

                # Decisión
                action = "HOLD"
                reason = ""
                emoji = "🟡"

                if pnl_pct <= -8:
                    action = "SELL"
                    reason = f"Pérdida grande ({pnl_pct:+.1f}%)"
                    emoji = "🔴"
                elif best and best.action == "SELL" and abs(best.score) >= 4:
                    action = "SELL"
                    reason = f"Señal SELL (score {best.score:.1f})"
                    emoji = "🔴"
                elif rsi > 78:
                    action = "SELL"
                    reason = f"Sobrecomprado (RSI {rsi:.0f})"
                    emoji = "🔴"
                elif trend == "BAJISTA" and pnl_pct > 5:
                    action = "SELL"
                    reason = f"Tendencia bajista, asegurar +{pnl_pct:.1f}%"
                    emoji = "🟠"
                elif pnl_pct >= 15:
                    action = "SELL"
                    reason = f"Buen beneficio, considerar venta parcial"
                    emoji = "🟠"
                elif best and best.action == "BUY" and best.score >= 6:
                    action = "BUY_MORE"
                    reason = f"Señal fuerte BUY (score {best.score:.1f})"
                    emoji = "🟢"
                elif trend == "ALCISTA" and rsi < 60:
                    action = "HOLD"
                    reason = "Tendencia alcista, aguanta"
                    emoji = "🟢"
                elif trend == "LATERAL":
                    action = "HOLD"
                    reason = "Lateral, sin prisa"
                    emoji = "🟡"
                else:
                    action = "HOLD"
                    reason = "Sin señal clara"
                    emoji = "🟡"

                cur = _currency_symbol(ticker)
                item = {
                    "ticker": ticker, "emoji": emoji, "action": action,
                    "reason": reason, "pnl_pct": pnl_pct, "value": value,
                    "price": price, "cur": cur, "trend": trend,
                }

                if action == "SELL":
                    sells.append(item)
                elif action == "BUY_MORE":
                    buys_more.append(item)
                else:
                    holds.append(item)

            # Formatear mensaje
            msg = "📋 <b>Revista de tu cartera</b>\n\n"

            if sells:
                msg += "🔴 <b>VENDER:</b>\n"
                for s in sells:
                    sign = "+" if s["pnl_pct"] >= 0 else ""
                    msg += f"  {s['emoji']} <b>{s['ticker']}</b> {sign}{s['pnl_pct']:.1f}% — {s['reason']}\n"
                msg += "\n"

            if buys_more:
                msg += "🟢 <b>AÑADIR MÁS:</b>\n"
                for b in buys_more:
                    sign = "+" if b["pnl_pct"] >= 0 else ""
                    msg += f"  {b['emoji']} <b>{b['ticker']}</b> {sign}{b['pnl_pct']:.1f}% — {b['reason']}\n"
                msg += "\n"

            if holds:
                msg += "🟡 <b>MANTENER:</b>\n"
                for h_item in holds:
                    sign = "+" if h_item["pnl_pct"] >= 0 else ""
                    msg += f"  {h_item['emoji']} <b>{h_item['ticker']}</b> {sign}{h_item['pnl_pct']:.1f}% — {h_item['reason']}\n"

            total_value = sum(s["value"] for s in sells + holds + buys_more)
            msg += f"\n💰 Total posiciones: <b>{total_value:.0f}€</b>"

            if not sells and not buys_more:
                msg += "\n\n✅ <i>Tu cartera está bien. No toques nada.</i>"

            await send_html(update, msg)

        elif intent == "optimize_portfolio":
            await send_html(update, "🔄 <i>Buscando mejores alternativas para tu cartera... (esto tarda un poco)</i>")

            positions = db.get_open_positions()
            if not positions:
                await send_html(update, "📭 No tienes posiciones abiertas.")
                return

            capital = db.get_capital()
            from config import DISCOVERY_UNIVERSE

            # 1. Puntuar cada posición actual
            my_scores = {}
            for pos in positions:
                pos = dict(pos)
                ticker = pos["ticker"]
                if ticker.startswith("_"):
                    continue

                price = get_current_price(ticker)
                if price is None:
                    continue

                entry = pos["entry_price"]
                pnl_pct = ((price - entry) / entry) * 100

                # Análisis técnico
                data = quick_analysis(ticker)
                if "error" in data:
                    continue

                trend = data.get("trend", "LATERAL")
                rsi = data.get("rsi", 50)

                # Score compuesto: tendencia + momentum + P&L actual
                score = 0.0
                if trend == "ALCISTA":
                    score += 2
                elif trend == "BAJISTA":
                    score -= 2
                if rsi > 70:
                    score -= 1  # sobrecomprado
                elif rsi < 30:
                    score += 1  # sobreventa = oportunidad
                if data.get("macd", 0) > data.get("macd_signal", 0):
                    score += 1
                else:
                    score -= 1
                # Penalizar si ya va mal
                if pnl_pct < -5:
                    score -= 1
                elif pnl_pct > 10:
                    score += 0.5

                my_scores[ticker] = {
                    "score": score, "pnl_pct": pnl_pct,
                    "trend": trend, "rsi": rsi,
                    "value": price * pos["shares"],
                    "price": price,
                }

            if not my_scores:
                await send_html(update, "❌ No pude analizar tus posiciones.")
                return

            # 2. Buscar alternativas en el universo (solo las que no tengo)
            my_tickers = set(my_scores.keys())
            candidates = [t for t in DISCOVERY_UNIVERSE if t not in my_tickers]

            # Analizar candidatos (sample para no tardar una eternidad)
            import random
            sample_size = min(30, len(candidates))
            sample = random.sample(candidates, sample_size)

            alt_scores = {}
            for ticker in sample:
                try:
                    data = quick_analysis(ticker)
                    if "error" in data:
                        continue

                    trend = data.get("trend", "LATERAL")
                    rsi = data.get("rsi", 50)

                    score = 0.0
                    if trend == "ALCISTA":
                        score += 2
                    elif trend == "BAJISTA":
                        score -= 2
                    if rsi > 70:
                        score -= 1
                    elif rsi < 30:
                        score += 1
                    if data.get("macd", 0) > data.get("macd_signal", 0):
                        score += 1
                    else:
                        score -= 1

                    # Bonus: señal fuerte
                    signals = analyze_ticker(ticker, capital)
                    if signals and signals[0].action == "BUY" and signals[0].score >= 5:
                        score += 2

                    alt_scores[ticker] = {
                        "score": score, "trend": trend,
                        "rsi": rsi, "price": data["price"],
                    }
                except Exception:
                    continue

            # 3. Encontrar swaps: peor posición mía → mejor alternativa
            swaps = []
            worst_positions = sorted(my_scores.items(), key=lambda x: x[1]["score"])
            best_alternatives = sorted(alt_scores.items(), key=lambda x: -x[1]["score"])

            used_alts = set()
            for my_ticker, my_data in worst_positions:
                for alt_ticker, alt_data in best_alternatives:
                    if alt_ticker in used_alts:
                        continue
                    # Solo sugerir swap si la alternativa es claramente mejor
                    improvement = alt_data["score"] - my_data["score"]
                    if improvement >= 2:
                        swaps.append({
                            "sell": my_ticker,
                            "sell_score": my_data["score"],
                            "sell_pnl": my_data["pnl_pct"],
                            "sell_trend": my_data["trend"],
                            "buy": alt_ticker,
                            "buy_score": alt_data["score"],
                            "buy_trend": alt_data["trend"],
                            "improvement": improvement,
                            "value": my_data["value"],
                        })
                        used_alts.add(alt_ticker)
                        break  # Solo un swap por posición

            # 4. Formatear
            msg = "🔄 <b>Optimización de cartera</b>\n\n"

            if swaps:
                msg += f"<b>{len(swaps)} cambio{'s' if len(swaps) > 1 else ''} sugerido{'s' if len(swaps) > 1 else ''}:</b>\n\n"
                for s in sorted(swaps, key=lambda x: -x["improvement"]):
                    sell_sign = "+" if s["sell_pnl"] >= 0 else ""
                    msg += (
                        f"🔴 Vende <b>{s['sell']}</b> ({sell_sign}{s['sell_pnl']:.1f}%, "
                        f"{s['sell_trend'].lower()}) ~{s['value']:.0f}€\n"
                        f"🟢 Compra <b>{s['buy']}</b> ({s['buy_trend'].lower()}, "
                        f"score {s['buy_score']:+.0f} vs {s['sell_score']:+.0f})\n"
                        f"📈 Mejora: <b>+{s['improvement']:.0f} puntos</b>\n\n"
                    )
            else:
                msg += "✅ <b>Tu cartera está bien.</b>\n"
                msg += "No encontré alternativas claramente mejores ahora mismo.\n"

            # Resumen de lo que no toqué
            untouched = [t for t in my_scores if t not in [s["sell"] for s in swaps]]
            if untouched and swaps:
                msg += "<b>Mantener:</b> " + ", ".join(untouched)

            msg += f"\n\n<i>Analicé {sample_size} alternativas de {len(candidates)} posibles.</i>"

            await send_html(update, msg)

        elif intent == "scan":
            if tracker.is_paused:
                await send_html(update,
                    f"⛔ <b>Recomendador pausado</b>\n<i>{h(tracker.pause_reason)}</i>\n\n"
                    "Puedes seguir operando manualmente."
                )
                return

            # ML como filtro: solo escanear tickers aprobados
            watchlist = db.get_watchlist()
            try:
                from ml_model import get_approved_tickers
                approved = get_approved_tickers()
                if approved is not None:
                    scan_tickers = [t for t in watchlist if t in approved]
                    await send_html(update,
                        f"🔍 <i>Escaneando {len(scan_tickers)} tickers aprobados por ML...</i>"
                    )
                else:
                    scan_tickers = watchlist
                    await send_html(update, "🔍 <i>Escaneando mercado...</i>")
            except Exception:
                scan_tickers = watchlist
                await send_html(update, "🔍 <i>Escaneando mercado...</i>")

            capital = db.get_capital()
            found = []

            for ticker in scan_tickers:
                signal = get_best_signal(ticker, capital)
                if signal and tracker.is_strategy_active(signal.strategy):
                    found.append(signal)

            if found:
                found.sort(key=lambda s: abs(s.score), reverse=True)
                msg = f"🎯 <b>Encontré {len(found)} oportunidad(es):</b>\n\n"
                await send_html(update, msg)

                for s in found[:3]:
                    await send_html(update, format_signal_html(s))

                    # Gráfica del mejor
                    if s == found[0]:
                        from charts import chart_technical_analysis
                        chart = chart_technical_analysis(s.ticker)
                        if chart:
                            await send_photo(update, chart, f"📈 {h(s.ticker)}")
            else:
                await send_html(update,
                    "😴 No encontré oportunidades claras ahora.\n"
                    "<i>Seguiré vigilando automáticamente.</i>"
                )

        elif intent == "analyze":
            ticker = extract_ticker(text)
            if not ticker:
                await send_html(update, "❓ ¿Qué acción quieres que analice? Dime el ticker o nombre.")
                return
            await _analyze_full(update, ticker)

        elif intent == "chart":
            ticker = extract_ticker(text)
            if not ticker:
                await send_html(update, "❓ ¿De qué acción quieres la gráfica?")
                return

            await send_html(update, f"📊 <i>Generando gráfica de {h(ticker)}...</i>")
            from charts import chart_technical_analysis
            chart = chart_technical_analysis(ticker)
            if chart:
                await send_photo(update, chart, f"📈 <b>{h(ticker)}</b>")
            else:
                await send_html(update, f"❌ No pude generar la gráfica de {h(ticker)}")

        elif intent == "compare":
            tickers = extract_multiple_tickers(text)
            if len(tickers) < 2:
                await send_html(update,
                    "❓ Necesito al menos 2 tickers.\n"
                    "Ejemplo: <code>compara AAPL MSFT GOOGL</code>"
                )
                return

            await send_html(update, f"📊 <i>Comparando {', '.join(tickers)}...</i>")
            from charts import chart_comparison
            chart = chart_comparison(tickers)
            if chart:
                await send_photo(update, chart,
                    f"📊 <b>Comparativa:</b> {', '.join(h(t) for t in tickers)}")
            else:
                await send_html(update, "❌ No pude generar la comparativa")

        elif intent == "market":
            await send_html(update, "🌍 <i>Cargando datos del mercado...</i>")
            watchlist = db.get_watchlist()
            from charts import get_market_data, chart_market_heatmap
            market_data = get_market_data(watchlist)
            if market_data:
                chart = chart_market_heatmap(market_data)
                if chart:
                    # Resumen texto
                    gainers = sorted(market_data, key=lambda x: x["change_pct"], reverse=True)
                    msg = "<b>🌍 Resumen del Mercado</b>\n\n"
                    msg += "<b>🟢 Top subidas:</b>\n"
                    for g in gainers[:3]:
                        msg += f"  {h(g['ticker'])}: +{g['change_pct']:.2f}% (${g['price']:.2f})\n"
                    msg += "\n<b>🔴 Top bajadas:</b>\n"
                    for g in gainers[-3:]:
                        s = "+" if g["change_pct"] >= 0 else ""
                        msg += f"  {h(g['ticker'])}: {s}{g['change_pct']:.2f}% (${g['price']:.2f})\n"

                    await send_photo(update, chart, msg)
                else:
                    await send_html(update, "❌ Error generando el heatmap")
            else:
                await send_html(update, "❌ No pude obtener datos del mercado")

        elif intent == "buy":
            ticker = extract_ticker(text)
            if not ticker:
                await send_html(update, "❓ ¿Qué acción quieres comprar?")
                return

            capital = db.get_capital()
            signal = get_best_signal(ticker, capital)

            result = execute_buy(ticker, signal)
            if result["success"]:
                cur = _currency_symbol(result['ticker'])
                pct = result.get('position_pct', 0.15)
                tier_label = "ALTA confianza" if pct >= 0.30 else "Normal"
                msg = (
                    f"✅ <b>Compra ejecutada!</b>\n\n"
                    f"📌 <b>{h(result['ticker'])}</b>: {result['shares']} acciones\n"
                    f"💲 Precio: <b>{result['price']:.2f}{cur}</b>\n"
                    f"💰 Coste total: <b>{result['total_cost']:.2f}€</b> "
                    f"({pct:.0%} del capital — {tier_label})\n"
                    f"🛑 Stop-loss: {result['stop_loss']:.2f}{cur}\n"
                    f"🎯 Take-profit: {result['take_profit']:.2f}{cur}\n"
                    f"💰 Capital restante: <b>{result['remaining_capital']:.2f}€</b>"
                )
                if result.get("strategy") and result["strategy"] != "manual":
                    msg += f"\n📋 Estrategia: <code>{h(result['strategy'])}</code>"
            else:
                msg = f"❌ No se pudo comprar: <i>{h(result['reason'])}</i>"

            await send_html(update, msg)

        elif intent == "sell":
            ticker = extract_ticker(text)
            if not ticker:
                await send_html(update, "❓ ¿Qué posición quieres cerrar?")
                return

            result = execute_sell(ticker, reason="manual")
            if result["success"]:
                pnl_s = "+" if result["net_pnl"] >= 0 else ""
                emoji = "🟢" if result["net_pnl"] >= 0 else "🔴"
                label = "Ganancia" if result["net_pnl"] >= 0 else "Pérdida"
                msg = (
                    f"✅ <b>Venta ejecutada!</b>\n\n"
                    f"📌 <b>{h(result['ticker'])}</b>: {result['shares']} acciones\n"
                    f"📍 {result['entry_price']:.2f}€ → {result['exit_price']:.2f}€\n"
                    f"{emoji} {label}: <b>{pnl_s}{result['net_pnl']:.2f}€</b> "
                    f"({pnl_s}{result['pnl_pct']:.1f}%)\n"
                    f"💰 Capital: <b>{result['new_capital']:.2f}€</b>"
                )
            else:
                msg = f"❌ No se pudo vender: <i>{h(result['reason'])}</i>"

            await send_html(update, msg)

        elif intent == "add_watch":
            ticker = extract_ticker(text)
            if not ticker:
                await send_html(update, "❓ ¿Qué ticker quieres añadir?")
                return
            db.add_to_watchlist(ticker)
            await send_html(update, f"✅ <b>{h(ticker)}</b> añadido a la watchlist")

        elif intent == "remove_watch":
            ticker = extract_ticker(text)
            if not ticker:
                await send_html(update, "❓ ¿Qué ticker quieres quitar?")
                return
            db.remove_from_watchlist(ticker)
            await send_html(update, f"🗑️ <b>{h(ticker)}</b> eliminado de la watchlist")

        elif intent == "watchlist":
            watchlist = db.get_watchlist()
            if watchlist:
                msg = "<b>📋 Watchlist:</b>\n\n"
                for t in watchlist:
                    msg += f"  • <code>{h(t)}</code>\n"
                msg += f"\n<i>Total: {len(watchlist)} tickers</i>\n"
                msg += "\n💡 <code>añade TICKER</code> / <code>quita TICKER</code>"
            else:
                msg = "<i>Watchlist vacía</i>"
            await send_html(update, msg)

        elif intent == "tracker":
            status = tracker.get_status()
            await send_html(update, format_tracker_html(status))

            # Gráfica de rendimiento por estrategia
            if status["strategies"]:
                from charts import chart_strategy_performance
                chart = chart_strategy_performance(status["strategies"])
                if chart:
                    await send_photo(update, chart, "📊 Rendimiento por estrategia")

        elif intent == "history":
            closed = db.get_closed_positions(10)
            if not closed:
                await send_html(update, "<i>No hay operaciones cerradas todavía.</i>")
                return

            msg = "<b>📜 Últimas operaciones:</b>\n\n"
            total_pnl = 0
            for pos in closed:
                pnl = pos["pnl"] or 0
                total_pnl += pnl
                pnl_s = "+" if pnl >= 0 else ""
                emoji = "🟢" if pnl >= 0 else "🔴"
                msg += (
                    f"{emoji} <b>{h(pos['ticker'])}</b>: {pos['shares']}x "
                    f"| {pos['entry_price']:.2f} → {pos['exit_price']:.2f}€ "
                    f"| <b>{pnl_s}{pnl:.2f}€</b>\n"
                )

            total_s = "+" if total_pnl >= 0 else ""
            msg += f"\n💵 Total: <b>{total_s}{total_pnl:.2f}€</b>"

            await send_html(update, msg)

            # Gráfica P&L si hay snapshots
            with db.get_connection() as conn:
                snapshots = conn.execute(
                    "SELECT * FROM daily_snapshots ORDER BY date"
                ).fetchall()
            if snapshots and len(snapshots) >= 2:
                from charts import chart_pnl_history
                snap_list = [dict(s) for s in snapshots]
                chart = chart_pnl_history(snap_list)
                if chart:
                    await send_photo(update, chart, "📈 Evolución del portfolio")

        elif intent == "news":
            ticker = extract_ticker(text)
            if not ticker:
                from sentiment import get_market_sentiment
                market = get_market_sentiment()
                sent_emoji = "🟢" if market.get("sentiment", 0) > 0.05 else "🔴" if market.get("sentiment", 0) < -0.05 else "⚪"
                msg = f"{sent_emoji} <b>Sentimiento del mercado:</b> {h(market['label'])}\n"
                msg += f"Score: <code>{market.get('sentiment', 0):.2f}</code>\n"
                if market.get("high_impact_events"):
                    msg += "\n⚠️ <b>Eventos de alto impacto:</b>\n"
                    for e in market["high_impact_events"]:
                        msg += f"  • <i>{h(e[:80])}</i>\n"
                await send_html(update, msg)
            else:
                from sentiment import get_news_sentiment
                await send_html(update, f"🔍 <i>Buscando noticias de {h(ticker)}...</i>")
                news = get_news_sentiment(ticker)
                if not news:
                    await send_html(update,
                        f"❌ No pude obtener noticias para {h(ticker)}.\n"
                        "<i>Verifica que ALPHA_VANTAGE_KEY esté configurado.</i>"
                    )
                    return

                sent_emoji = "🟢" if news["sentiment"] > 0.05 else "🔴" if news["sentiment"] < -0.05 else "⚪"
                msg = (
                    f"📰 <b>Noticias de {h(ticker)}</b>\n\n"
                    f"{sent_emoji} Sentimiento: <b>{h(news['label'])}</b> ({news['sentiment']:.2f})\n"
                    f"📄 Artículos: {news['articles']}\n"
                )
                if news["high_impact"]:
                    msg += "⚠️ <b>ALTO IMPACTO detectado</b>\n"
                if news.get("details"):
                    msg += "\n<b>Titulares:</b>\n"
                    for d in news["details"]:
                        s_emoji = "🟢" if d["score"] > 0.1 else "🔴" if d["score"] < -0.1 else "⚪"
                        msg += f"  {s_emoji} <i>{h(d['title'][:70])}</i>\n"
                await send_html(update, msg)

        elif intent == "calendar":
            from calendar_eco import get_economic_calendar
            events = get_economic_calendar(days_ahead=7)
            if events is None:
                await send_html(update,
                    "❌ No pude obtener el calendario.\n"
                    "<i>Verifica que FINNHUB_KEY esté configurado.</i>"
                )
            elif not events:
                await send_html(update, "📅 <i>No hay eventos económicos importantes esta semana.</i>")
            else:
                msg = "📅 <b>Calendario Económico</b>\n\n"
                for e in events[:12]:
                    impact_emoji = "🔴" if e["impact"] in ("high", "3") else "🟡"
                    est = f" (est: {e['estimate']})" if e.get("estimate") else ""
                    prev = f" (prev: {e['previous']})" if e.get("previous") else ""
                    actual = f" → <b>{e['actual']}</b>" if e.get("actual") else ""

                    msg += (
                        f"{impact_emoji} <b>{h(e['event'])}</b>\n"
                        f"   🌍 {h(e['country'])} | 📅 {h(e['date'][:16])}{h(est)}{h(prev)}{actual}\n\n"
                    )
                await send_html(update, msg)

        elif intent == "momentum":
            await send_html(update, "📊 <i>Calculando portfolio momentum...</i>")
            try:
                from momentum_rotation import format_momentum_portfolio, rank_etfs
                from hmm_regime import get_current_regime
                regime = get_current_regime()
                regime_emoji = {"BULL": "🟢", "BEAR": "🔴", "SIDEWAYS": "🟡"}.get(regime, "⚪")
                msg = f"{regime_emoji} Régimen: <b>{regime}</b>\n\n"
                msg += format_momentum_portfolio()

                rankings = rank_etfs()
                if rankings:
                    msg += "\n\n<b>Ranking completo:</b>\n"
                    for r in rankings:
                        medal = "🥇🥈🥉"[r["rank"]-1] if r["rank"] <= 3 else f"{r['rank']}."
                        msg += f"  {medal} <b>{r['ticker']}</b> {r['return_12m']:+.1f}%\n"

                await send_html(update, msg)
            except Exception as e:
                logger.error(f"Error mostrando momentum: {e}")
                await send_html(update, "❌ Error calculando momentum portfolio.")

        elif intent == "pead":
            try:
                from pead_strategy import format_pead_status, get_earnings_calendar
                msg = format_pead_status()

                earnings = get_earnings_calendar()
                surprises = [e for e in earnings if e["surprise_pct"] >= 5]
                if surprises:
                    msg += "\n\n<b>Sorpresas recientes (+5%):</b>\n"
                    for e in sorted(surprises, key=lambda x: -x["surprise_pct"])[:5]:
                        msg += f"  📈 <b>{e['ticker']}</b> +{e['surprise_pct']:.0f}% ({e['date']})\n"

                await send_html(update, msg)
            except Exception as e:
                logger.error(f"Error mostrando PEAD: {e}")
                await send_html(update, "❌ Error obteniendo datos de earnings.")

        elif intent == "regime":
            try:
                from hmm_regime import format_hmm_status
                msg = format_hmm_status()
                await send_html(update, msg)
            except Exception as e:
                logger.error(f"Error mostrando régimen: {e}")
                await send_html(update, "❌ Error obteniendo régimen de mercado.")

        elif intent == "backtest":
            ticker = extract_ticker(text)
            if not ticker:
                await send_html(update,
                    "❓ ¿Qué ticker quieres probar?\n"
                    "Ejemplo: <code>backtest AAPL</code>\n"
                    "  • <code>backtest AAPL 1y</code> → último año\n"
                    "  • <code>backtest AAPL 2y ema_crossover</code> → estrategia específica"
                )
                return

            # Parse period and strategy from text
            words = text.lower().split()
            period = "2y"
            strategy = None
            for w in words:
                if w in ("1y", "2y", "3y", "5y", "6mo"):
                    period = w
                if w in ("ema_crossover", "rsi_macd", "mean_reversion"):
                    strategy = w

            await send_html(update,
                f"🔬 <i>Backtesting {h(ticker)} ({period})"
                f"{' - ' + strategy if strategy else ''}...</i>"
            )

            from backtest import run_backtest, format_backtest_results
            results = run_backtest(ticker, period=period, strategy=strategy)
            await send_html(update, format_backtest_results(results))

        elif intent == "optimize":
            ticker = extract_ticker(text)
            if ticker:
                await send_html(update,
                    f"⚙️ <i>Optimizando parámetros para {h(ticker)}... (320 combinaciones, tarda ~2 min)</i>"
                )
                from optimizer import optimize_parameters, format_optimization_results
                results = optimize_parameters(ticker)
                await send_html(update, format_optimization_results(results))
            else:
                await send_html(update,
                    "⚙️ <i>Optimizando parámetros para toda la watchlist... (puede tardar ~5 min)</i>"
                )
                from optimizer import optimize_watchlist, format_optimization_results
                watchlist = db.get_watchlist()
                results = optimize_watchlist(watchlist[:8])
                await send_html(update, format_optimization_results(results))

        elif intent == "ml_train":
            await send_html(update,
                "🧠 <i>Entrenando modelo ML con datos históricos... (puede tardar ~2 min)</i>"
            )
            from ml_model import train_model, format_ml_status
            watchlist = db.get_watchlist()
            results = train_model(watchlist)
            await send_html(update, format_ml_status(results))

        elif intent == "ml_predict":
            ticker = extract_ticker(text)
            if not ticker:
                await send_html(update, "❓ ¿Qué ticker quieres predecir? Ejemplo: <code>predice AAPL</code>")
                return

            from ml_model import predict_signal
            pred = predict_signal(ticker)
            if pred is None:
                await send_html(update,
                    "⚠️ No hay modelo entrenado.\n"
                    "Escribe <code>entrena</code> para entrenar el modelo primero."
                )
                return

            prob = pred["probability"]
            bar = "█" * int(prob * 10) + "░" * (10 - int(prob * 10))
            action_emoji = "🟢 BUY" if pred["action"] == "BUY" else "⚪ HOLD"

            msg = (
                f"🧠 <b>Predicción ML: {h(ticker)}</b>\n\n"
                f"{action_emoji}\n"
                f"📊 Probabilidad: [{bar}] {prob:.0%}\n\n"
                f"<b>Features clave:</b>\n"
            )
            for feat, imp in pred["top_features"][:5]:
                msg += f"  • {h(feat)}: {imp:+.3f}\n"

            await send_html(update, msg)

        elif intent == "ml_approved":
            from ml_model import format_approved_tickers
            await send_html(update, format_approved_tickers())

        elif intent == "tr_setup":
            if not tr_sync.is_configured:
                await send_html(update,
                    "⚠️ <b>Trade Republic no configurado</b>\n\n"
                    "Necesito estas variables en el <code>.env</code>:\n"
                    "  • <code>TR_PHONE=+34XXXXXXXXX</code>\n"
                    "  • <code>TR_PIN=XXXX</code>\n\n"
                    "<i>Luego reinicia el bot y escribe</i> <code>tr conecta</code>"
                )
                return

            await send_html(update, "🔄 <i>Iniciando registro con Trade Republic...</i>")
            result = tr_sync.start_web_login()
            if result["success"]:
                await send_html(update,
                    "✅ <b>Código enviado a tu móvil</b>\n\n"
                    "Trade Republic te ha enviado un código por SMS/push.\n"
                    f"Escribe: <code>tr confirma CÓDIGO</code>\n\n"
                    "⚠️ <i>Esto cerrará tu sesión en la app de TR</i>"
                )
            else:
                await send_html(update, f"❌ Error: {h(result['error'])}")

        elif intent == "tr_confirm":
            # Extraer código del mensaje
            words = text.split()
            code = None
            for w in words:
                if w.isdigit() and len(w) == 4:
                    code = w
                    break

            if not code:
                await send_html(update, "❓ No encontré el código. Escribe: <code>tr confirma 1234</code>")
                return

            result = tr_sync.confirm_web_login(code)
            if result["success"]:
                await send_html(update,
                    "✅ <b>Sesión iniciada con Trade Republic!</b>\n\n"
                    "Ahora puedes usar:\n"
                    "  • <code>tr portfolio</code> → Ver tu cartera de TR\n"
                    "  • <code>sincroniza</code> → Sincronizar con el bot"
                )
            else:
                await send_html(update, f"❌ {h(result['error'])}")

        elif intent == "tr_portfolio":
            if not tr_sync.is_configured:
                await send_html(update,
                    "⚠️ Trade Republic no configurado. Escribe <code>tr conecta</code>"
                )
                return

            await send_html(update, "🔄 <i>Consultando Trade Republic...</i>")
            portfolio = await tr_sync.get_portfolio()

            if not portfolio:
                await send_html(update,
                    "❌ No pude conectar con TR.\n"
                    "<i>Puede que necesites reconectar: </i><code>tr conecta</code>"
                )
                return

            msg = (
                "<b>🏦 Portfolio Trade Republic</b>\n\n"
                f"💰 Cash: <b>{portfolio['cash']:.2f}€</b>\n"
                f"🏦 Valor total: <b>{portfolio['total_value']:.2f}€</b>\n"
            )

            if portfolio["positions"]:
                msg += f"\n<b>Posiciones ({len(portfolio['positions'])}):</b>\n"
                for pos in portfolio["positions"]:
                    pnl_s = "+" if pos["pnl"] >= 0 else ""
                    emoji = "🟢" if pos["pnl"] >= 0 else "🔴"
                    msg += (
                        f"\n{emoji} <b>{h(pos['ticker'])}</b>"
                        f" ({h(pos.get('name', '')[:20])})\n"
                        f"   {pos['shares']:.2f}x @ {pos['avg_cost']:.2f}€\n"
                        f"   💵 {pnl_s}{pos['pnl']:.2f}€ ({pnl_s}{pos['pnl_pct']:.1f}%)\n"
                    )
            else:
                msg += "\n<i>No hay posiciones abiertas en TR</i>\n"

            msg += f"\n<i>🕐 {portfolio['synced_at'][:19]}</i>"
            await send_html(update, msg)

        elif intent == "tr_sync":
            if not tr_sync.is_configured:
                await send_html(update,
                    "⚠️ Trade Republic no configurado. Escribe <code>tr conecta</code>"
                )
                return

            await send_html(update, "🔄 <i>Sincronizando con Trade Republic...</i>")

            # Primero comparar
            sync = await tr_sync.sync_to_db()
            if not sync["success"]:
                await send_html(update, f"❌ {h(sync['error'])}")
                return

            if sync["in_sync"]:
                await send_html(update,
                    "✅ <b>Todo sincronizado!</b>\n\n"
                    f"💰 Capital: {sync['tr_cash']:.2f}€\n"
                    f"📌 Posiciones: {len(sync['tr_portfolio']['positions'])}\n"
                    f"🏦 Valor total: {sync['tr_portfolio']['total_value']:.2f}€"
                )
                return

            # Hay diferencias — mostrarlas
            msg = "⚠️ <b>Diferencias encontradas:</b>\n\n"

            if sync["capital_diff"] > 1.0:
                msg += (
                    f"💰 <b>Capital</b>\n"
                    f"   Bot: {sync['local_capital']:.2f}€\n"
                    f"   TR: {sync['tr_cash']:.2f}€\n\n"
                )

            for pos in sync["only_in_tr"]:
                msg += (
                    f"🆕 <b>{h(pos['ticker'])}</b> solo en TR\n"
                    f"   {pos['shares']:.2f}x @ {pos['avg_cost']:.2f}€\n\n"
                )

            for pos in sync["only_in_local"]:
                msg += (
                    f"🗑️ <b>{h(pos['ticker'])}</b> solo en bot (ya no en TR)\n"
                    f"   {pos['shares']}x @ {pos['entry_price']:.2f}€\n\n"
                )

            for m in sync["mismatches"]:
                msg += (
                    f"⚠️ <b>{h(m['ticker'])}</b> shares diferentes\n"
                    f"   Bot: {m['local_shares']}x | TR: {m['tr_shares']:.2f}x\n\n"
                )

            msg += "Escribe <code>sincroniza forzar</code> para actualizar el bot con los datos de TR."
            await send_html(update, msg)

            # Si el usuario pide forzar
            if "forzar" in text.lower() or "force" in text.lower():
                result = await tr_sync.force_sync()
                if result.get("synced"):
                    msg = "✅ <b>Sincronización completada:</b>\n\n"
                    for change in result.get("changes", []):
                        msg += f"  • {h(change)}\n"
                    await send_html(update, msg)

        elif intent == "alert_add":
            ticker = extract_ticker(text)
            if not ticker:
                await send_html(update,
                    "❓ ¿Qué acción quieres vigilar?\n"
                    "Ejemplo: <code>avísame cuando AAPL esté para comprar</code>"
                )
                return
            added = db.add_ticker_alert(ticker, chat_id)
            if added:
                await send_html(update,
                    f"🔔 <b>Alerta activada para {h(ticker)}</b>\n\n"
                    f"Te avisaré cuando las condiciones sean buenas para comprar.\n"
                    f"Reviso cada 30 min durante horario de mercado.\n\n"
                    f"🟢 Score ≥5 → Momento de comprar\n"
                    f"🟡 Score 3-4 → Se está calentando\n\n"
                    f"Para desactivar: <code>quita alerta {h(ticker)}</code>"
                )
            else:
                await send_html(update,
                    f"ℹ️ Ya tienes una alerta activa para <b>{h(ticker)}</b>"
                )

        elif intent == "alert_remove":
            ticker = extract_ticker(text)
            if not ticker:
                await send_html(update,
                    "❓ ¿Qué alerta quieres quitar?\n"
                    "Ejemplo: <code>quita alerta AAPL</code>"
                )
                return
            removed = db.remove_ticker_alert(ticker, chat_id)
            if removed:
                await send_html(update, f"🔕 Alerta de <b>{h(ticker)}</b> desactivada.")
            else:
                await send_html(update, f"ℹ️ No tenías alerta activa para <b>{h(ticker)}</b>")

        elif intent == "alert_list":
            alerts = db.get_ticker_alerts(chat_id)
            if not alerts:
                await send_html(update,
                    "🔕 No tienes alertas activas.\n\n"
                    "Crea una con: <code>avísame cuando AAPL esté para comprar</code>"
                )
                return
            msg = "🔔 <b>Tus alertas activas:</b>\n\n"
            for a in alerts:
                score_str = f" (score: {a['last_score']:.0f})" if a["last_score"] is not None else ""
                status = "🟢" if a["green_sent"] else ("🟡" if a["yellow_sent"] else "⏳")
                msg += f"{status} <b>{h(a['ticker'])}</b>{score_str}\n"
            msg += f"\nQuitar: <code>quita alerta TICKER</code>"
            await send_html(update, msg)

        elif intent == "kick_user":
            if chat_id != TELEGRAM_CHAT_ID:
                await send_html(update, "🔒 Solo el admin puede eliminar usuarios.")
                return
            # Buscar nombre en el texto
            words = text.split()
            target_name = " ".join(w for w in words[1:]
                                   if w.lower() not in {"usuario", "a", "de", "eliminar",
                                                         "elimina", "quita", "expulsar",
                                                         "expulsa", "kick", "dar", "baja",
                                                         "bloquear", "bloquea"})
            target_name = target_name.strip()
            if not target_name:
                await send_html(update,
                    "❓ ¿A quién quieres eliminar?\n"
                    "Ejemplo: <code>eliminar usuario Eduardo</code>"
                )
                return
            # Buscar usuario por nombre
            users = db.get_all_users()
            match = None
            for u in users:
                if u["name"].lower() == target_name.lower() and u["chat_id"] != TELEGRAM_CHAT_ID:
                    match = u
                    break
            if not match:
                names = [u["name"] for u in users if u["chat_id"] != TELEGRAM_CHAT_ID and u["status"] == "active"]
                if names:
                    await send_html(update,
                        f"❓ No encuentro a <b>{h(target_name)}</b>.\n"
                        f"Usuarios activos: {', '.join(h(n) for n in names)}"
                    )
                else:
                    await send_html(update, "ℹ️ No hay usuarios que eliminar (solo tú).")
                return
            db.deactivate_user(match["chat_id"])
            await send_html(update, f"🚫 <b>{h(match['name'])}</b> eliminado del bot.")

        elif intent == "invite":
            # Solo admin puede invitar
            if chat_id != TELEGRAM_CHAT_ID:
                await send_html(update, "🔒 Solo el admin puede generar invitaciones.")
                return
            # Extraer nombre/label del texto
            words = text.split()
            label = " ".join(w for w in words[1:]
                             if w.lower() not in {"a", "para", "invitar", "invita",
                                                   "invite", "código", "codigo",
                                                   "genera", "dar", "acceso", "alta", "de"})
            label = label.strip() or "invitado"
            code = db.create_invite_code(chat_id, label)
            bot_username = (await context.bot.get_me()).username
            bot_link = f"https://t.me/{bot_username}"

            # Mensaje para el admin
            await send_html(update,
                f"🎟️ <b>Invitación para {h(label)}</b>\n\n"
                f"Código: <code>{code}</code>\n"
                f"Reenvíale el siguiente mensaje 👇"
            )
            # Mensaje listo para reenviar
            await send_html(update,
                f"👋 Te han invitado al bot de trading!\n\n"
                f"1️⃣ Abre el bot: {bot_link}\n"
                f"2️⃣ Dale a <b>Iniciar</b>\n"
                f"3️⃣ Pega este código:\n\n"
                f"<code>{code}</code>\n\n"
                f"Con eso ya recibirás las alertas."
            )

        elif intent == "users":
            if chat_id != TELEGRAM_CHAT_ID:
                await send_html(update, "🔒 Solo el admin puede ver los usuarios.")
                return
            users = db.get_all_users()
            if not users:
                await send_html(update, "👤 No hay usuarios registrados.")
                return
            msg = "👥 <b>Usuarios del bot:</b>\n\n"
            for u in users:
                status_emoji = "✅" if u["status"] == "active" else "❌"
                msg += f"{status_emoji} <b>{h(u['name'])}</b> — {u['created_at'][:10]}\n"
            pending = db.get_pending_invites(chat_id)
            if pending:
                msg += f"\n🎟️ <b>Invitaciones pendientes:</b>\n"
                for inv in pending:
                    msg += f"  <code>{inv['code']}</code> — {h(inv['label'] or '?')}\n"
            await send_html(update, msg)

        elif intent == "prompt":
            # Guardar prompt para Claude
            prompt_text = text.split(maxsplit=1)[1] if len(text.split(maxsplit=1)) > 1 else ""
            if not prompt_text:
                await send_html(update, "❓ Escribe: <code>prompt tu mensaje aquí</code>")
                return
            import os
            os.makedirs("data", exist_ok=True)
            with open("data/prompt_queue.txt", "a", encoding="utf-8") as f:
                f.write(f"{datetime.now().isoformat()}|{prompt_text}\n")
            await send_html(update, "📨 <b>Prompt enviado a Claude.</b>\n<i>Te responderé cuando lo procese.</i>")

        else:
            ticker = extract_ticker(text)
            if ticker:
                await send_html(update, f"🔍 <i>Analizando {h(ticker)}...</i>")
                data = quick_analysis(ticker)
                await send_html(update, format_analysis_html(data))
            else:
                await send_html(update,
                    "❓ No entendí. Escribe /ayuda o usa el menú (/) para ver qué puedo hacer."
                )

    except Exception as e:
        logger.error(f"Error procesando mensaje: {e}", exc_info=True)
        await update.message.reply_text("❌ Error procesando tu mensaje. Inténtalo de nuevo.")


async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Handler principal de mensajes de texto (NLP)."""
    if not await _check_auth(update, context):
        return
    # Log incoming message
    text = update.message.text
    chat_id = str(update.effective_chat.id)
    user = update.effective_user
    user_name = user.first_name or user.username or "unknown"
    intent = detect_intent(text)
    db.log_chat(chat_id, user_name, "in", text, intent=intent)
    await _dispatch_intent(update, context, text)


# ═══════════════════════════════════════════
#  Comandos / (menú de Telegram)
# ═══════════════════════════════════════════

async def _cmd_handler(update: Update, context: ContextTypes.DEFAULT_TYPE, virtual_text: str):
    """Handler genérico: convierte un /comando en texto y lo despacha por NLP."""
    if not await _check_auth(update, context):
        return
    if context.args:
        virtual_text += " " + " ".join(context.args)
    await _dispatch_intent(update, context, virtual_text)


async def cmd_start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Mensaje de bienvenida al iniciar el bot."""
    if not await _check_auth(update, context):
        return
    await send_html(update,
        "👋 <b>¡Bienvenido al Bot de Trading!</b>\n\n"
        "Analizo acciones, gestiono tu cartera y busco oportunidades.\n\n"
        "🚀 <b>Empieza aquí:</b>\n"
        "  /ejemplo → Tutorial interactivo\n"
        "  /ayuda → Todos los comandos\n\n"
        "💬 <i>También puedes escribirme en natural: ¿compro Apple?</i>"
    )


async def cmd_portfolio(update, context):
    await _cmd_handler(update, context, "cartera")


async def cmd_escanear(update, context):
    await _cmd_handler(update, context, "busca oportunidades")


async def cmd_mercado(update, context):
    await _cmd_handler(update, context, "mercado")


async def cmd_analiza(update, context):
    await _cmd_handler(update, context, "analiza")


async def cmd_noticias(update, context):
    await _cmd_handler(update, context, "noticias")


async def cmd_revista(update, context):
    await _cmd_handler(update, context, "revista")


async def cmd_alertas(update, context):
    await _cmd_handler(update, context, "mis alertas")


async def cmd_watchlist(update, context):
    await _cmd_handler(update, context, "watchlist")


async def cmd_historial(update, context):
    await _cmd_handler(update, context, "historial")


async def cmd_calendario(update, context):
    await _cmd_handler(update, context, "calendario")


async def cmd_tracker(update, context):
    await _cmd_handler(update, context, "tracker")


async def cmd_backtest(update, context):
    await _cmd_handler(update, context, "backtest")


async def cmd_regimen(update, context):
    await _cmd_handler(update, context, "regimen")


async def cmd_guia(update, context):
    await _cmd_handler(update, context, "guía")


async def cmd_ejemplo(update, context):
    await _cmd_handler(update, context, "ejemplo")


async def cmd_ayuda(update, context):
    await _cmd_handler(update, context, "ayuda")


async def cmd_llm(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Estado del servicio LLM (Ollama)."""
    if not await _check_auth(update, context):
        return
    try:
        from ollama import get_status
        s = get_status()
        status_emoji = "🟢" if s["available"] else "🔴"
        circuit = "ABIERTO (pausa)" if s["circuit_open"] else "cerrado (ok)"
        msg = (
            f"🧠 <b>Estado LLM (Ollama)</b>\n\n"
            f"{status_emoji} Disponible: <b>{'Sí' if s['available'] else 'No'}</b>\n"
            f"🔌 URL: <code>{s['url']}</code>\n"
            f"⚡ Modelo rápido: <code>{s['model_fast']}</code>\n"
            f"🧪 Modelo razonamiento: <code>{s['model_reasoning']}</code>\n"
            f"🔒 Circuit breaker: {circuit}\n"
            f"📦 Cache: {s['cache_size']} respuestas"
        )
    except Exception as e:
        msg = f"🧠 <b>LLM no disponible:</b> {h(str(e)[:200])}"
    await send_html(update, msg)


async def _post_init(app: Application):
    """Registra el menú de comandos en Telegram al arrancar."""
    commands = [
        BotCommand("portfolio", "📊 Mis posiciones"),
        BotCommand("escanear", "🔍 Buscar oportunidades"),
        BotCommand("mercado", "🗺️ Mapa del mercado"),
        BotCommand("analiza", "📈 Analizar acción — /analiza AAPL"),
        BotCommand("noticias", "📰 Sentimiento — /noticias AAPL"),
        BotCommand("revista", "🔎 Revisar cartera: vender/mantener"),
        BotCommand("alertas", "🔔 Alertas activas"),
        BotCommand("watchlist", "👀 Lista de seguimiento"),
        BotCommand("historial", "📋 Operaciones cerradas"),
        BotCommand("calendario", "📅 Eventos económicos"),
        BotCommand("tracker", "🎯 Precisión del bot"),
        BotCommand("llm", "🧠 Estado del cerebro IA"),
        BotCommand("ejemplo", "📖 Tutorial paso a paso"),
        BotCommand("ayuda", "❓ Todos los comandos"),
    ]
    await app.bot.set_my_commands(commands)
    logger.info(f"Menú de comandos registrado ({len(commands)} comandos)")


async def send_notification(app: Application, message: str):
    """Envía una notificación proactiva a todos los usuarios activos."""
    recipients = db.get_active_users()
    if not recipients:
        recipients = [TELEGRAM_CHAT_ID]

    # Log una vez (notificación, no por cada recipient)
    clean = re.sub(r'<[^>]+>', '', message)
    db.log_chat("system", "bot", "out", clean[:2000], message_type="notification")

    for cid in recipients:
        try:
            await app.bot.send_message(
                chat_id=cid, text=message, parse_mode=ParseMode.HTML
            )
        except Exception as e:
            logger.error(f"Error enviando notificación a {cid}: {e}")
            try:
                await app.bot.send_message(chat_id=cid, text=clean)
            except Exception:
                pass


async def send_notification_photo(app: Application, photo_bytes: bytes, caption: str = ""):
    """Envía una foto como notificación proactiva a todos los usuarios activos."""
    recipients = db.get_active_users()
    if not recipients:
        recipients = [TELEGRAM_CHAT_ID]

    # Guardar media y loguear
    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
    media_path = db.save_media(photo_bytes, f"notif_{ts}.png")
    clean_caption = re.sub(r'<[^>]+>', '', caption) if caption else ""
    db.log_chat("system", "bot", "out", clean_caption, message_type="photo", media_path=media_path)

    for cid in recipients:
        try:
            await app.bot.send_photo(
                chat_id=cid,
                photo=io.BytesIO(photo_bytes),
                caption=caption,
                parse_mode=ParseMode.HTML
            )
        except Exception as e:
            logger.error(f"Error enviando foto a {cid}: {e}")


async def handle_document(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Maneja documentos enviados (PDFs de Trade Republic)."""
    if not db.is_authorized_user(str(update.effective_chat.id)):
        return

    doc = update.message.document
    if not doc:
        return

    filename = doc.file_name or ""
    chat_id = str(update.effective_chat.id)
    user = update.effective_user
    user_name = user.first_name or user.username or "unknown"

    if not filename.lower().endswith(".pdf"):
        await send_html(update, "❓ Solo acepto PDFs de Trade Republic.")
        return

    # Log incoming document
    db.log_chat(chat_id, user_name, "in", f"[PDF: {filename}]", message_type="document")

    await send_html(update, "📄 <i>Procesando PDF...</i>")

    try:
        # Descargar archivo
        file = await context.bot.get_file(doc.file_id)
        pdf_bytes = await file.download_as_bytearray()

        # Extraer texto del PDF
        import subprocess
        import tempfile
        import os

        with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as tmp:
            tmp.write(pdf_bytes)
            tmp_path = tmp.name

        # Usar python para extraer texto (pdfplumber si disponible, sino básico)
        try:
            import pdfplumber
            with pdfplumber.open(tmp_path) as pdf:
                text = "\n".join(page.extract_text() or "" for page in pdf.pages)
        except ImportError:
            # Fallback: leer como bytes y buscar strings
            text = pdf_bytes.decode("latin-1", errors="ignore")

        os.unlink(tmp_path)

        if not text.strip():
            await send_html(update, "❌ No pude leer el PDF. ¿Es un extracto de Trade Republic?")
            return

        # Parsear
        from tr_pdf_parser import parse_tr_pdf, format_portfolio_summary

        result = parse_tr_pdf(text)
        if not result:
            await send_html(update, "❌ No reconozco este PDF. Envíame el extracto de cuenta de valores o de criptomonedas de Trade Republic.")
            return

        # Guardar en data/ para referencia
        import json
        os.makedirs("data", exist_ok=True)
        cache_file = f"data/tr_{result['type']}.json"
        with open(cache_file, "w") as f:
            json.dump(result, f, indent=2, default=str)

        # Sincronizar con DB
        from config import STOP_LOSS_PCT, TAKE_PROFIT_PCT, COMMISSION_PER_TRADE
        synced = 0
        for pos in result["positions"]:
            ticker = pos["ticker"]
            if ticker.startswith("_"):
                continue  # Skip fondos privados sin ticker

            # ¿Ya existe posición abierta?
            existing = db.get_position_by_ticker(ticker)
            if not existing:
                price = pos.get("price", 0) or pos["value_eur"] / pos["shares"] if pos["shares"] > 0 else 0
                sl = price * (1 - STOP_LOSS_PCT)
                tp = price * (1 + TAKE_PROFIT_PCT)
                db.open_position(
                    ticker=ticker, shares=pos["shares"],
                    entry_price=price, stop_loss=sl, take_profit=tp,
                    commission=COMMISSION_PER_TRADE * 2,
                )
                synced += 1

        # Actualizar capital en config
        total_value = result["total_value"]

        # Formatear respuesta
        msg = format_portfolio_summary(
            result if result["type"] == "securities" else None,
            result if result["type"] == "crypto" else None,
        )
        if synced > 0:
            msg += f"\n\n✅ {synced} posiciones nuevas sincronizadas."
        else:
            msg += "\n\n✅ Todas las posiciones ya estaban registradas."

        await send_html(update, msg)

    except Exception as e:
        logger.error(f"Error procesando PDF: {e}")
        await send_html(update, f"❌ Error procesando PDF: {h(str(e)[:200])}")


def create_bot() -> Application:
    """Crea y configura la aplicación del bot."""
    app = Application.builder().token(TELEGRAM_TOKEN).post_init(_post_init).build()

    # Comandos / (menú de Telegram)
    app.add_handler(CommandHandler("start", cmd_start))
    app.add_handler(CommandHandler("portfolio", cmd_portfolio))
    app.add_handler(CommandHandler("escanear", cmd_escanear))
    app.add_handler(CommandHandler("mercado", cmd_mercado))
    app.add_handler(CommandHandler("analiza", cmd_analiza))
    app.add_handler(CommandHandler("noticias", cmd_noticias))
    app.add_handler(CommandHandler("revista", cmd_revista))
    app.add_handler(CommandHandler("alertas", cmd_alertas))
    app.add_handler(CommandHandler("watchlist", cmd_watchlist))
    app.add_handler(CommandHandler("historial", cmd_historial))
    app.add_handler(CommandHandler("calendario", cmd_calendario))
    app.add_handler(CommandHandler("tracker", cmd_tracker))
    app.add_handler(CommandHandler("backtest", cmd_backtest))
    app.add_handler(CommandHandler("regimen", cmd_regimen))
    app.add_handler(CommandHandler("guia", cmd_guia))
    app.add_handler(CommandHandler("ejemplo", cmd_ejemplo))
    app.add_handler(CommandHandler("ayuda", cmd_ayuda))
    app.add_handler(CommandHandler("llm", cmd_llm))

    # NLP handler (todo lo que no sea comando /)
    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
    app.add_handler(MessageHandler(filters.Document.PDF, handle_document))
    return app