main.py

"""
main.py — Punto de entrada del trading bot
Orquesta todo: datos → indicadores → señal → riesgo → ejecución.

Cómo funciona el loop principal:
─────────────────────────────────
Cada N minutos (según TIMEFRAME):
  1. Obtener las últimas velas de Massive
  2. Calcular SMA y RSI
  3. Evaluar la señal (BUY / SELL / HOLD)
  4. Si hay posición abierta → comprobar stop-loss y take-profit
  5. Si la señal es BUY y no hay posición → calcular cantidad y comprar
  6. Si la señal es SELL y hay posición → vender

Para arrancar el bot:
  python main.py

Para pararlo:
  Ctrl + C  (el bot cerrará limpiamente)
"""

import logging
import time
import sys
import schedule

# Configuración del sistema de logs — debe ir antes de cualquier import del bot
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s | %(levelname)-8s | %(name)s — %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
    handlers=[
        logging.StreamHandler(sys.stdout),                    # Consola
        logging.FileHandler("logs/bot.log", encoding="utf-8") # Archivo
    ],
)
logger = logging.getLogger("main")

import config
from data.massive_client import MassiveClient
from broker.alpaca_client import AlpacaClient
from strategy.indicators import add_all_indicators
from strategy.sma_rsi import get_signal, BUY, SELL, HOLD
from risk.manager import RiskManager


# ── Inicialización de los módulos ─────────────────────────────────────────────
massive  = MassiveClient()
alpaca   = AlpacaClient()
risk_mgr = RiskManager()

SYMBOL = config.TRADING_SYMBOL

# Mínimo de velas necesarias para calcular los indicadores
# (necesitamos al menos SMA_LONG velas + margen)
MIN_CANDLES = config.SMA_LONG + 10


def run_bot_cycle():
    """
    Un ciclo completo del bot. Se ejecuta en cada iteración del scheduler.
    """
    logger.info("=" * 60)
    logger.info(f"▶ Iniciando ciclo | Símbolo: {SYMBOL}")

    # ── 1. Comprobar si el mercado está abierto ───────────────────────────────
    if not alpaca.is_market_open():
        logger.info("⏸  Mercado cerrado. Esperando próximo ciclo.")
        return

    # ── 2. Obtener datos de Massive ───────────────────────────────────────────
    try:
        df = massive.get_candles(
            symbol=SYMBOL,
            timeframe=config.TIMEFRAME,
            limit=MIN_CANDLES,
        )
    except Exception as e:
        logger.error(f"Error obteniendo datos de Massive: {e}")
        return

    if len(df) < MIN_CANDLES:
        logger.warning(f"Pocas velas ({len(df)}). Se necesitan {MIN_CANDLES}.")
        return

    # ── 3. Calcular indicadores técnicos ──────────────────────────────────────
    df = add_all_indicators(df)

    # ── 4. Obtener precio y posición actual ───────────────────────────────────
    current_price = float(df["close"].iloc[-1])
    position = alpaca.get_position(SYMBOL)

    # ── 5. Gestión de posición abierta (stop-loss / take-profit) ─────────────
    if position is not None:
        entry_price = float(position.avg_entry_price)
        qty = float(position.qty)

        if risk_mgr.should_stop_loss(entry_price, current_price):
            logger.warning(f"🛑 Ejecutando STOP-LOSS en {SYMBOL}")
            alpaca.close_position(SYMBOL)
            return

        if risk_mgr.should_take_profit(entry_price, current_price):
            logger.info(f"🎯 Ejecutando TAKE-PROFIT en {SYMBOL}")
            alpaca.close_position(SYMBOL)
            return

    # ── 6. Evaluar señal de la estrategia ────────────────────────────────────
    signal = get_signal(df)

    # ── 7. Ejecutar la señal ──────────────────────────────────────────────────
    if signal == BUY and position is None:
        # No tenemos posición → podemos comprar
        cash = alpaca.get_balance()
        qty = risk_mgr.calculate_quantity(current_price, cash)

        if qty > 0:
            alpaca.buy_market(SYMBOL, qty)
        else:
            logger.warning("Cantidad calculada es 0. No se ejecuta la compra.")

    elif signal == SELL and position is not None:
        # Tenemos posición → cerramos
        alpaca.close_position(SYMBOL)

    elif signal == BUY and position is not None:
        logger.info("Señal BUY pero ya tenemos posición abierta. HOLD.")

    elif signal == SELL and position is None:
        logger.info("Señal SELL pero no hay posición que cerrar. HOLD.")

    logger.info(f"✔ Ciclo completado")


def main():
    logger.info("🤖 Trading Bot iniciado")
    logger.info(f"   Símbolo:    {SYMBOL}")
    logger.info(f"   Modo:       {config.ALPACA_MODE.upper()}")
    logger.info(f"   Timeframe:  {config.TIMEFRAME}")
    logger.info(f"   Capital máx: ${config.MAX_CAPITAL:,.2f}")
    logger.info(f"   Riesgo/trade: {config.RISK_PER_TRADE*100:.1f}%")
    logger.info(f"   Stop-loss:    {config.STOP_LOSS_PCT*100:.1f}%")
    logger.info(f"   Take-profit:  {config.TAKE_PROFIT_PCT*100:.1f}%")

    # Ejecutar un ciclo inmediatamente al arrancar
    run_bot_cycle()

    # Programar ejecuciones periódicas según el timeframe
    # Ajusta el intervalo según tu timeframe (aquí: cada 15 minutos)
    interval_minutes = _timeframe_to_minutes(config.TIMEFRAME)
    schedule.every(interval_minutes).minutes.do(run_bot_cycle)
    logger.info(f"⏱  Próximo ciclo en {interval_minutes} minutos.")

    try:
        while True:
            schedule.run_pending()
            time.sleep(30)  # Comprueba el scheduler cada 30 segundos
    except KeyboardInterrupt:
        logger.info("⛔ Bot detenido por el usuario (Ctrl+C).")
        logger.info("   Cancelando órdenes pendientes...")
        alpaca.cancel_all_orders()
        logger.info("   Bot apagado de forma segura. ¡Hasta luego!")


def _timeframe_to_minutes(timeframe: str) -> int:
    """Convierte el string de timeframe a minutos para el scheduler."""
    mapping = {
        "1Min":  1,
        "5Min":  5,
        "15Min": 15,
        "30Min": 30,
        "1Hour": 60,
        "1Day":  1440,
    }
    return mapping.get(timeframe, 15)


if __name__ == "__main__":
    main()